Co to jest Rack?
Rack zapewnia minimalny interfejs pomiędzy serwerami obsługującymi Ruby i frameworki Ruby.
Za pomocą Rack możesz napisać aplikację Rack.
Rack przekaże skrót środowiska (skrót, zawarty w żądaniu HTTP klienta, składającym się z nagłówków podobnych do CGI) do aplikacji w stojaku, która może korzystać z rzeczy zawartych w tym skrócie, aby robić, co chce.
Co to jest aplikacja do montażu w szafie serwerowej?
Aby użyć Rack, musisz dostarczyć „aplikację” - obiekt, który reaguje na #callmetodę za pomocą funkcji skrótu środowiska jako parametru (zazwyczaj zdefiniowanej jako env). #callmusi zwrócić tablicę dokładnie trzech wartości:
- Stan kod (na przykład „200”),
- Hash nagłówków ,
- ciała Response (który musi odpowiedzieć na metodzie Ruby,
each).
Możesz napisać aplikację Rack, która zwróci taką tablicę - zostanie ona odesłana do klienta przez Rack, w odpowiedzi (faktycznie będzie to instancja klasy Rack::Response[kliknij, aby przejść do dokumentów]).
Bardzo prosta aplikacja do montażu w szafie:
gem install rack- Utwórz
config.ruplik - Rack wie, że tego szuka.
Będziemy tworzyć niewielką aplikację regałowe, które zwraca odpowiedź (instancję Rack::Response) Kto ciała Response jest tablicą, która zawiera ciąg: "Hello, World!".
Uruchomimy lokalny serwer za pomocą polecenia rackup.
Odwiedzając odpowiedni port w naszej przeglądarce, zobaczymy „Witaj, świecie!” renderowane w rzutni.
#./message_app.rb
class MessageApp
def call(env)
[200, {}, ['Hello, World!']]
end
end
#./config.ru
require_relative './message_app'
run MessageApp.new
Uruchom serwer lokalny rackupi odwiedź localhost: 9292 , powinieneś zobaczyć „Witaj, świecie!” renderowane.
Nie jest to wyczerpujące wyjaśnienie, ale zasadniczo to, co się tutaj dzieje, polega na tym, że klient (przeglądarka) wysyła żądanie Rack do Rack, za pośrednictwem lokalnego serwera, a Rack tworzy instancję MessageAppi uruchamia się call, przekazując funkcję Hash środowiska jako parametr do metody ( envargument).
Rack pobiera wartość zwracaną (tablicę) i używa jej do utworzenia instancji Rack::Responsei przesyła ją z powrotem do klienta. Przeglądarka używa magii do drukowania „Witaj, świecie!” do ekranu.
Nawiasem mówiąc, jeśli chcesz zobaczyć, jak wygląda skrót środowiska, po prostu umieść go puts envpod spodem def call(env).
Choć jest minimalna, napisałeś tutaj o aplikacji Rack!
Interakcja aplikacji Rack z hashem środowiska przychodzącego
W naszej małej aplikacji Rack możemy wchodzić w interakcje z envskrótem (zobacz tutaj więcej na temat skrótu środowiska).
Zaimplementujemy możliwość wprowadzania przez użytkownika własnego ciągu zapytania do adresu URL, dlatego ciąg ten będzie obecny w żądaniu HTTP, enkapsulowany jako wartość w jednej z par klucz / wartość skrótu środowiska.
Nasza aplikacja Rack uzyska dostęp do ciągu zapytania z mieszania środowiska i odeśle go z powrotem do klienta (w tym przypadku naszej przeglądarki) za pośrednictwem treści w odpowiedzi.
Z dokumentacji Rack na temat skrótu środowiska:
„QUERY_STRING: Część adresu URL żądania, która następuje po znaku?, Jeśli istnieje. Może być pusta, ale zawsze wymagana!”
#./message_app.rb
class MessageApp
def call(env)
message = env['QUERY_STRING']
[200, {}, [message]]
end
end
Teraz rackupi odwiedź localhost:9292?hello( ?hellojest ciąg zapytania) i powinieneś zobaczyć „witaj” renderowane w okienku ekranu.
Rack Middleware
Będziemy:
- włóż kawałek Rack Middleware w naszym kodzie - klasę:
MessageSetter,
- hash Środowisko trafi do tej klasy pierwszej i zostanie przekazany jako parametr:
env,
MessageSetterwstawi 'MESSAGE'klucz do skrótu env, jego wartością jest 'Hello, World!'if , jeśli env['QUERY_STRING']jest pusty; env['QUERY_STRING']Jeśli nie,- wreszcie powróci
@app.call(env)- @appbędąc obok aplikacji w „stack”: MessageApp.
Po pierwsze, wersja „długiej ręki”:
#./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
Z dokumentacji Rack :: Builder widzimy, że Rack::Builderimplementuje małą DSL do iteracyjnego konstruowania aplikacji Rack. Zasadniczo oznacza to, że możesz zbudować „stos” składający się z co najmniej jednego oprogramowania pośredniego i aplikacji „najniższego poziomu” do wysłania. Wszystkie żądania przechodzące do aplikacji na najniższym poziomie zostaną najpierw przetworzone przez oprogramowanie pośrednie.
#useokreśla oprogramowanie pośrednie, które ma być używane na stosie. Jako argument przyjmuje oprogramowanie pośrednie.
Oprogramowanie pośredniczące w szafie musi:
- mieć konstruktor, który przyjmuje następną aplikację na stosie jako parametr.
- zareagować na
callmetodę, która przyjmuje jako parametr parametr skrótu środowiska.
W naszym przypadku „Middleware” to MessageSetter„konstruktor” to initializemetoda MessageSetter , „następna aplikacja” na stosie MessageApp.
Więc tutaj, ze względu na to, co Rack::Builderrobi pod maską appargument MessageSetter„s initializemetody jest MessageApp.
(obejrzyj się wyżej, zanim przejdziesz dalej)
Dlatego każdy element oprogramowania pośredniego zasadniczo „przekazuje” istniejący skrót środowiska do następnej aplikacji w łańcuchu - więc masz możliwość mutowania tego skrótu środowiska w oprogramowaniu pośrednim przed przekazaniem go do następnej aplikacji na stosie.
#runpobiera argument, który jest obiektem, który odpowiada #calli zwraca odpowiedź Rack (instancja Rack::Response).
Wnioski
Korzystając z niego Rack::Builder, możesz konstruować łańcuchy oprogramowania pośredniego, a każde żądanie aplikacji zostanie przetworzone przez każde oprogramowanie pośrednie, zanim ostatecznie zostanie przetworzone przez ostatni element stosu (w naszym przypadku MessageApp). Jest to niezwykle przydatne, ponieważ oddziela różne etapy przetwarzania żądań. Jeśli chodzi o „rozdzielenie obaw”, nie może być dużo czystsze!
Możesz zbudować „potok zapytań” składający się z kilku Middlewares, które zajmują się takimi rzeczami jak:
- Poświadczenie
- Upoważnienie
- Buforowanie
- Dekoracja
- Monitorowanie wydajności i użytkowania
- Wykonanie (faktycznie obsłużyć żądanie i podać odpowiedź)
(powyżej punktorów z innej odpowiedzi w tym wątku)
Często zobaczysz to w profesjonalnych aplikacjach Sinatra. Sinatra używa Rack! Zobacz tutaj do zdefiniowania co Sinatra JEST !
Na koniec config.rumożemy napisać w skrócie, oferując dokładnie taką samą funkcjonalność (i to zwykle zobaczysz):
require_relative './message_app'
require_relative './middleware/message_setter'
use MessageSetter
run MessageApp.new
Aby dokładniej pokazać, co MessageAppsię dzieje, oto jego wersja „długiej ręki”, która wyraźnie pokazuje, że #calltworzy nową instancję Rack::Response, z wymaganymi trzema argumentami.
class MessageApp
def call(env)
Rack::Response.new([env['MESSAGE']], 200, {})
end
end
Przydatne linki
