Che cos'è Rack?
Rack fornisce un'interfaccia minima tra i server Web che supportano i framework Ruby e Ruby.
Utilizzando Rack è possibile scrivere un'applicazione Rack.
Rack passerà l'hash Environment (un hash, contenuto all'interno di una richiesta HTTP da un client, costituito da intestazioni simili a CGI) all'applicazione Rack che può usare le cose contenute in questo hash per fare quello che vuole.
Che cos'è un'applicazione rack?
Per utilizzare Rack, è necessario fornire un'app, un oggetto che risponde al #callmetodo con l'hash dell'ambiente come parametro (generalmente definito come env). #calldeve restituire una matrice con esattamente tre valori:
- il codice di stato (ad esempio "200"),
- un hash di intestazioni ,
- il corpo di risposta (che deve rispondere al metodo Ruby
each).
Puoi scrivere un'applicazione Rack che restituisce un tale array - questo verrà rispedito al tuo client, da Rack, all'interno di una risposta (questa sarà in realtà un'istanza della classe Rack::Response[fai clic per andare ai documenti]).
Un'applicazione rack molto semplice:
gem install rack- Crea un
config.rufile: Rack sa cercarlo.
Creeremo una piccola applicazione rack che restituisce una risposta (un'istanza Rack::Response) che è corpo di risposta è un array che contiene una stringa: "Hello, World!".
Accenderemo un server locale usando il comando rackup.
Quando visiteremo la porta pertinente nel nostro browser vedremo "Ciao, mondo!" reso nel viewport.
#./message_app.rb
class MessageApp
def call(env)
[200, {}, ['Hello, World!']]
end
end
#./config.ru
require_relative './message_app'
run MessageApp.new
Avvia un server locale con rackupe visita localhost: 9292 e dovresti vedere 'Hello, World!' reso.
Questa non è una spiegazione esaustiva, ma essenzialmente ciò che accade qui è che il Client (il browser) invia una richiesta HTTP a Rack, tramite il server locale, e Rack istanzia MessageApped esegue call, passando l'Hash Ambiente come parametro nel metodo ( l' envargomento).
Il rack accetta il valore restituito (l'array) e lo utilizza per creare un'istanza di Rack::Responsee inviarlo al client. Il browser utilizza la magia per stampare "Hello, World!" allo schermo.
Per inciso, se vuoi vedere com'è l'hash dell'ambiente, mettici puts envsotto def call(env).
Per quanto minimale, quello che hai scritto qui è un'applicazione Rack!
Far interagire un'applicazione Rack con l'hash dell'ambiente Incoming
Nella nostra piccola app Rack, possiamo interagire con l' envhash (vedi qui per ulteriori informazioni sull'hash dell'ambiente).
Implementeremo la possibilità per l'utente di inserire la propria stringa di query nell'URL, pertanto tale stringa sarà presente nella richiesta HTTP, incapsulata come valore in una delle coppie chiave / valore dell'hash Environment.
La nostra app Rack accederà a quella stringa di query dall'hash Environment e la invierà al client (il nostro browser, in questo caso) tramite il Body in the Response.
Dai documenti Rack sull'hash dell'ambiente:
"QUERY_STRING: la parte dell'URL della richiesta che segue il?, Se presente. Può essere vuota, ma è sempre richiesta!"
#./message_app.rb
class MessageApp
def call(env)
message = env['QUERY_STRING']
[200, {}, [message]]
end
end
Ora, rackupvisita localhost:9292?hello( ?helloessendo la stringa della query) e dovresti vedere 'ciao' reso nel viewport.
Middleware Rack
Noi:
- inserire un pezzo di cremagliera Middleware nella nostra base di codice - una classe:
MessageSetter,
- l'hash Ambiente colpirà questa classe prima e verrà passato come parametro:
env,
MessageSetterinserirà una 'MESSAGE'chiave nell'hash di env, il cui valore è 'Hello, World!'se env['QUERY_STRING']è vuoto; env['QUERY_STRING']altrimenti,- infine, tornerà
@app.call(env)- @appdi essere la prossima app nel 'stack': MessageApp.
Innanzitutto, la versione "long-hand":
#./middleware/message_setter.rb
class MessageSetter
def initialize(app)
@app = app
end
def call(env)
if env['QUERY_STRING'].empty?
env['MESSAGE'] = 'Hello, World!'
else
env['MESSAGE'] = env['QUERY_STRING']
end
@app.call(env)
end
end
#./message_app.rb (same as before)
class MessageApp
def call(env)
message = env['QUERY_STRING']
[200, {}, [message]]
end
end
#config.ru
require_relative './message_app'
require_relative './middleware/message_setter'
app = Rack::Builder.new do
use MessageSetter
run MessageApp.new
end
run app
Dai documenti Rack :: Builder vediamo che Rack::Builderimplementa un piccolo DSL per costruire iterativamente applicazioni Rack. Ciò significa sostanzialmente che è possibile creare uno "Stack" composto da uno o più Middleware e un'applicazione di "livello inferiore" a cui inviare. Tutte le richieste che passano all'applicazione di livello inferiore verranno prima elaborate dal tuo Middleware.
#usespecifica il middleware da utilizzare in una pila. Prende il middleware come argomento.
Il Middleware Rack deve:
- avere un costruttore che accetta l'applicazione successiva nello stack come parametro.
- rispondere al
callmetodo che utilizza l'hash Environment come parametro.
Nel nostro caso, il "Middleware" è MessageSetter, il "costruttore" è il initializemetodo di MessageSetter , la "prossima applicazione" nello stack è MessageApp.
Così qui, a causa di ciò che Rack::Builderha sotto il cofano, l' appargomento del MessageSetter's initializemetodo è MessageApp.
(aggira la testa prima di andare avanti)
Pertanto, ogni pezzo di Middleware essenzialmente "passa" l'hash Ambiente esistente alla successiva applicazione nella catena - quindi hai l'opportunità di mutare l'hash ambiente all'interno del Middleware prima di passarlo all'applicazione successiva nello stack.
#runaccetta un argomento che è un oggetto che risponde #calle restituisce una risposta in rack (un'istanza di Rack::Response).
conclusioni
Usando Rack::Builderpuoi costruire catene di Middleware e qualsiasi richiesta alla tua applicazione verrà elaborata da ciascun Middleware a sua volta prima di essere infine elaborata dal pezzo finale nello stack (nel nostro caso MessageApp). Ciò è estremamente utile perché separa le diverse fasi di elaborazione delle richieste. In termini di "separazione delle preoccupazioni", non potrebbe essere molto più pulito!
Puoi costruire una 'pipeline di richieste' composta da diversi Middleware che trattano cose come:
- Autenticazione
- Autorizzazione
- caching
- Decorazione
- Monitoraggio delle prestazioni e dell'utilizzo
- Esecuzione (effettivamente gestire la richiesta e fornire una risposta)
(sopra i punti elenco di un'altra risposta su questa discussione)
Lo vedrai spesso nelle applicazioni Sinatra professionali. Sinatra usa Rack! Vedi qui per la definizione di ciò che Sinatra È !
Come nota finale, il nostro config.rupuò essere scritto in uno stile di breve durata, producendo esattamente la stessa funzionalità (e questo è ciò che vedrai in genere):
require_relative './message_app'
require_relative './middleware/message_setter'
use MessageSetter
run MessageApp.new
E per mostrare più esplicitamente ciò che MessageAppsta facendo, ecco la sua versione "long-hand" che mostra esplicitamente che #callsta creando una nuova istanza di Rack::Response, con i tre argomenti richiesti.
class MessageApp
def call(env)
Rack::Response.new([env['MESSAGE']], 200, {})
end
end
Link utili
