Lua - Webprogrammierung

Lua ist eine hochflexible Sprache und wird häufig auf mehreren Plattformen einschließlich Webanwendungen verwendet. Die Kepler-Community, die 2004 gegründet wurde, um Open-Source-Webkomponenten in Lua bereitzustellen.

Obwohl andere Web-Frameworks mit Lua entwickelt wurden, konzentrieren wir uns hauptsächlich auf die Komponenten, die von der Kepler-Community bereitgestellt werden.

Anwendungen und Frameworks

Orbit ist ein MVC-Webframework für Lua, das auf WSAPI basiert.
WSAPI ist die API, die den Webhostserver von Lua-Webanwendungen abstrahiert und die Basis für viele Projekte ist.
Xavante ist ein Lua-Webserver, der eine WSAPI-Schnittstelle bietet.
Sputnik ist ein Wiki / CMS, das über WSAPI im Kepler-Projekt entwickelt wurde und für Humor und Unterhaltung verwendet wird.
CGILuabietet die Erstellung von LuaPages- und LuaScripts-Webseiten an, basierend auf WSAPI, aber nicht mehr unterstützt. Verwenden Sie stattdessen Orbit, Sputnik oder WSAPI.

In diesem Tutorial werden wir versuchen, Ihnen zu vermitteln, was Lua kann, und um mehr über seine Installation und Verwendung zu erfahren, lesen Sie bitte die Website

Orbit

Orbit ist ein MVC-Webframework für Lua. Das CGILua-Modell der "Skripte" wird vollständig zugunsten von Anwendungen aufgegeben, bei denen jede Orbit-Anwendung in eine einzelne Datei passen kann. Sie können sie jedoch bei Bedarf in mehrere Dateien aufteilen.

Alle Orbit-Anwendungen folgen dem WSAPI-Protokoll und arbeiten derzeit mit Xavante, CGI und Fastcgi. Es enthält einen Launcher, mit dem eine Xavante-Instanz einfach für die Entwicklung gestartet werden kann.

Der einfachste Weg, Orbit zu installieren, ist die Verwendung von LuaRocks. Luarocks Install Orbit ist der Befehl zur Installation. Dazu müssen Sie zuerst LuaRocks installieren .

Wenn Sie nicht alle Abhängigkeiten installiert haben, müssen Sie die folgenden Schritte ausführen, um Orbit in einer Unix / Linux-Umgebung einzurichten.

Apache installieren

Stellen Sie eine Verbindung zu Ihrem Server her. Installieren Sie Apache2, seine Support-Module und aktivieren Sie die erforderlichen Apache2-Module mit -

$ 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

Installieren Sie LuaRocks

$ sudo apt-get install luarocks

Installieren Sie WSAPI, FCGI, Orbit und Xavante

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

Apache2 einrichten

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

Fügen Sie diesen folgenden Abschnitt unter dem Abschnitt <Directory / var / www /> der Konfigurationsdatei hinzu. Wenn dieser Abschnitt "AllowOverride None" enthält, müssen Sie "None" in "All" ändern, damit die .htaccess-Datei die Konfiguration lokal überschreiben kann.

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

Starten Sie den Server neu, um sicherzustellen, dass die vorgenommenen Änderungen wirksam werden.

Um Ihre Anwendung zu aktivieren, müssen Sie einer .htaccess-Datei im Stammverzeichnis Ihrer Orbit-Anwendung + ExecCGI hinzufügen - in diesem Fall / var / www.

Options +ExecCGI
DirectoryIndex index.ws

Einfaches Beispiel - Umlaufbahn

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

Jetzt sollten Sie Ihren Webbrowser starten können. Gehen Sie zu http: // localhost: 8080 / und Sie sollten die folgende Ausgabe sehen -

First Page

Orbit bietet eine weitere Option, dh Lua-Code kann HTML generieren.

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

Formulare erstellen

Ein einfaches Formularbeispiel ist unten dargestellt -

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

Wie bereits erwähnt, fungiert WSAPI als Basis für viele Projekte und enthält mehrere eingebettete Funktionen. Sie können WSAPI verwenden und die folgenden Plattformen unterstützen:

Windows
UNIX-basierte Systeme

Die von WSAPI unterstützten Server und Schnittstellen umfassen:

CGI
FastCGI
Xavante

WSAPI bietet eine Reihe von Bibliotheken, die uns die Webprogrammierung mit Lua erleichtern. Einige der unterstützten Funktionen in Lua umfassen:

Anfrage bearbeiten
Ausgabepufferung
Authentication
Datei-Uploads
Isolation anfordern
Multiplexing

Ein einfaches Beispiel für WSAPI ist unten dargestellt -

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

Sie können im obigen Code sehen, dass eine einfache HTML-Seite gebildet und zurückgegeben wird. Sie können die Verwendung von Coroutinen sehen, die es ermöglichen, Anweisung für Anweisung an die aufrufende Funktion zurückzugeben. Schließlich werden der HTML-Statuscode (200), die Header und die HTML-Seite zurückgegeben.

Xavante

Xavante ist ein Lua HTTP 1.1-Webserver, der eine modulare Architektur verwendet, die auf URI-zugeordneten Handlern basiert. Xavante bietet derzeit an,

Dateihandler
Handler umleiten
WSAPI-Handler

Der Dateihandler wird für allgemeine Dateien verwendet. Der Redirect-Handler aktiviert die URI-Neuzuordnung und den WSAPI-Handler für die Handhabung mit WSAPI-Anwendungen.

Ein einfaches Beispiel ist unten gezeigt.

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

Um virtuelle Hosts mit Xavante zu verwenden, wird der Aufruf von xavante.HTTP wie folgt geändert:

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

Lua Webkomponenten

Copas, ein Dispatcher basierend auf Coroutinen, die von TCP / IP-Servern verwendet werden können.
Cosmo, eine "sichere Vorlagen" -Engine, die Ihre Anwendung vor beliebigem Code in den Vorlagen schützt.
Coxpcall kapselt Lua native pcall und xpcall mit Coroutine-kompatiblen.
LuaFileSystem, eine tragbare Möglichkeit, auf die zugrunde liegende Verzeichnisstruktur und Dateiattribute zuzugreifen.
Rings, eine Bibliothek, die eine Möglichkeit bietet, neue Lua-Zustände innerhalb von Lua zu erstellen.

Schlussbemerkung

Es gibt so viele Lua-basierte Web-Frameworks und -Komponenten, die je nach Bedarf ausgewählt werden können. Es sind andere Web-Frameworks verfügbar, die Folgendes umfassen:

Moonstalkermöglicht die effiziente Entwicklung und das Hosting dynamisch generierter webbasierter Projekte, die mit der Sprache Lua erstellt wurden; von einfachen Seiten bis zu komplexen Anwendungen.
Lapis, ein Framework zum Erstellen von Webanwendungen mit MoonScript (oder Lua), das in einer angepassten Version von Nginx namens OpenResty ausgeführt wird.
Lua Server Pages, ein Plug-In für die Lua-Scripting-Engine, das jeden anderen Ansatz für die Entwicklung eingebetteter Websites zunichte macht, bietet eine dramatische Abkürzung zu herkömmlichen C-Serverseiten.

Diese Web-Frameworks können Ihre Webanwendungen nutzen und Sie bei leistungsstarken Vorgängen unterstützen.