रैक मिडलवेयर क्या है?

Question

रूबी में रैक मिडलवेयर क्या है? मुझे "मिडलवेयर" से जो मतलब है, उसके लिए कोई अच्छी व्याख्या नहीं मिली।

Comments

RailsGuide पर एक मार्गदर्शिका भी है जो अब बड़े पैमाने पर रैक को कवर करती है, जिसमें मिडलवेयर भी शामिल है: guide.rubyonrails.org/rails_on_rack.html

— xji

PhusionPassenger टीम को बहुत-बहुत धन्यवाद, उनके ब्लॉग पर एक अच्छी तरह से समझाया गया लेख है। rubyraptor.org/…

— लामियन

रैक और रैक मिडलवेयर को इस लेख में समझाया गया है । रैक आधारित एप्लिकेशन बनाने के बारे में भी बताया।

— शाश्वत श्रीवास्तव

Answer 1

डिजाइन के रूप में रैक

रैक मिडलवेयर "अनुरोध और प्रतिक्रिया को फ़िल्टर करने का एक तरीका" से अधिक है - यह रैक का उपयोग करने वाले वेब सर्वर के लिए पाइपलाइन डिज़ाइन पैटर्न का कार्यान्वयन है ।

यह बहुत ही सफाई से एक अनुरोध को संसाधित करने के विभिन्न चरणों को अलग करता है - सभी अच्छी तरह से डिज़ाइन किए गए सॉफ़्टवेयर उत्पादों का एक प्रमुख लक्ष्य होने के नाते चिंताओं को अलग करना।

रैक के साथ उदाहरण के लिए मेरे पास पाइपलाइन के अलग-अलग चरण हो सकते हैं:

• प्रमाणीकरण : जब अनुरोध आता है, तो क्या उपयोगकर्ता लॉगऑन विवरण सही हैं? मैं इस OAuth, HTTP मूल प्रमाणीकरण, नाम / पासवर्ड को कैसे मान्य कर सकता हूँ?

• प्राधिकरण : "क्या उपयोगकर्ता इस विशेष कार्य को करने के लिए अधिकृत है?", अर्थात भूमिका-आधारित सुरक्षा।

• कैशिंग : क्या मैंने इस अनुरोध को पहले ही संसाधित कर दिया है, क्या मैं एक कैश्ड परिणाम वापस कर सकता हूं?

• सजावट : मैं डाउनस्ट्रीम प्रसंस्करण को बेहतर बनाने के अनुरोध को कैसे बढ़ा सकता हूं?

• प्रदर्शन और उपयोग की निगरानी : अनुरोध और प्रतिक्रिया से मुझे क्या आँकड़े मिल सकते हैं?

• निष्पादन : वास्तव में अनुरोध को संभालना और प्रतिक्रिया प्रदान करना।

विभिन्न चरणों को अलग करने में सक्षम होने (और वैकल्पिक रूप से उन्हें शामिल करना) अच्छी तरह से संरचित अनुप्रयोगों को विकसित करने में एक बड़ी मदद है।

समुदाय

रैक मिडलवेयर के आसपास भी एक बेहतरीन इको-सिस्टम विकसित हो रहा है - आपको उपरोक्त सभी चरणों को करने के लिए पूर्व-निर्मित रैक घटकों को खोजने में सक्षम होना चाहिए। मिडलवेयर की सूची के लिए रैक गिटहब विकी देखें ।

मिडलवेयर क्या है?

मिडलवेयर एक भयानक शब्द है जो किसी भी सॉफ़्टवेयर घटक / लाइब्रेरी को संदर्भित करता है जो कि सहायता करता है लेकिन किसी कार्य के निष्पादन में सीधे शामिल नहीं होता है। बहुत सामान्य उदाहरण लॉगिंग, प्रमाणीकरण और अन्य सामान्य, क्षैतिज प्रसंस्करण घटक हैं । ये ऐसी चीजें हैं जो हर किसी को कई अनुप्रयोगों में चाहिए होती हैं, लेकिन बहुत से लोग खुद को बनाने में रुचि रखते हैं (या होनी चाहिए)।

अधिक जानकारी

• अनुरोधों को फ़िल्टर करने का एक तरीका होने के बारे में टिप्पणी शायद RailsCast एपिसोड 151: रैक मिडलवेयर स्क्रीन कास्ट से आती है ।

• रैक मिडलवेयर रैक के बाहर विकसित हुआ और रैक मिडलवेयर के परिचय में एक महान पहचान है ।

• यहां विकिपीडिया पर मिडलवेयर का परिचय है ।

Comments

एक बात मैं अस्पष्ट हूँ: क्या सभी मिडलवेयर एक ही डेटा साझा करते हैं? क्या सुरक्षा के लिए उन्हें (यानी सैंडबॉक्स एक) अलग करना संभव है?

— ब्रायन आर्मस्ट्रांग

रैक आपके आवेदन का हिस्सा है, इसलिए सभी मिडलवेयर डेटासेट अनुरोध की एक ही प्रति है और प्रत्येक इसे किसी भी तरह से संशोधित कर सकता है जो वे चाहते हैं। AFAIK, उन्हें सैंडबॉक्स करने का कोई तरीका नहीं है उसी तरह एक ही प्रक्रिया के भीतर एक वस्तु को दूसरे से सैंडबॉक्स करने का कोई तरीका नहीं है (रूबी सैंडबॉक्सिंग के बावजूद प्रयास)।

— क्रिस मैकॉले

और समझते हैं कि रैक रैक से अलग है।

— मनीष श्रीवास्तव

मैं मिडलवेयर के बारे में सोचना पसंद करता हूं, जो कुछ भी है जो मेरे ऐप के बीच में बैठता है, जो मैंने कोडित किया है और जो मेरे सर्वर से जाता है ... जो कि रैकस्पेस पर होस्ट किया गया है। 'रैक मिडलवेयर' शब्द भ्रमित करने का कारण है, जैसा कि हम सभी जानते हैं, यह इसलिए है क्योंकि यह कन्फ्यूशियस था जिसने 2000 से अधिक साल पहले सभी मूल रैक मिडलवेयर को लिखा था। फ्रांस में।

— 17

Answer 2

सबसे पहले, रैक बिल्कुल दो चीजें हैं:

• एक वेबसर्वर इंटरफ़ेस सम्मेलन
• एक रत्न

रैक - वेबसर्वर इंटरफ़ेस

रैक की बहुत मूल बातें एक साधारण सम्मेलन है। हर रैक आज्ञाकारी वेबसर्वर हमेशा एक ऑब्जेक्ट पर कॉल विधि देगा जिसे आप उसे देते हैं और उस पद्धति के परिणाम की सेवा करते हैं। रैक वास्तव में निर्दिष्ट करता है कि इस कॉल विधि को कैसा दिखना है, और इसे वापस क्या करना है। वह रैक है।

आइए इसे एक सरल प्रयास दें। मैं WEBrick का उपयोग रैक आज्ञाकारी वेबसर्वर के रूप में करूँगा, लेकिन उनमें से कोई भी करेगा। आइए एक साधारण वेब एप्लिकेशन बनाएं जो JSON स्ट्रिंग लौटाता है। इसके लिए हम config.ru नामक एक फाइल बनाएंगे। Config.ru को स्वचालित रूप से रैक मणि के कमांड रैकअप द्वारा बुलाया जाएगा जो कि रैक-आज्ञाकारी वेबसर्वर में config.ru की सामग्री को केवल चलाएगा। तो चलिए config.ru फ़ाइल में निम्नलिखित जोड़ते हैं:

class JSONServer
  def call(env)
    [200, {"Content-Type" => "application/json"}, ['{ "message" : "Hello!" }']]
  end
end

map '/hello.json' do
  run JSONServer.new
end

जैसा कि सम्मेलन निर्दिष्ट करता है कि हमारे सर्वर में एक विधि है जिसे कॉल कहा जाता है जो एक पर्यावरण हैश को स्वीकार करता है और वेबसर्वर की सेवा के लिए प्रपत्र [स्थिति, हेडर, बॉडी] के साथ एक सरणी देता है। चलो इसे बस रैकअप कहकर आज़माते हैं। एक डिफ़ॉल्ट रैक आज्ञाकारी सर्वर, शायद WEBrick या Mongrel शुरू हो जाएगा और तुरंत सेवा के लिए अनुरोधों की प्रतीक्षा करेगा।

$ rackup
[2012-02-19 22:39:26] INFO  WEBrick 1.3.1
[2012-02-19 22:39:26] INFO  ruby 1.9.3 (2012-01-17) [x86_64-darwin11.2.0]
[2012-02-19 22:39:26] INFO  WEBrick::HTTPServer#start: pid=16121 port=9292

आइए अपने नए JSON सर्वर का परीक्षण या तो कर्लिंग या url http://localhost:9292/hello.jsonऔर वॉइला पर जाकर करें :

$ curl http://localhost:9292/hello.json
{ message: "Hello!" }

यह काम करता हैं। महान! यह हर वेब फ्रेमवर्क का आधार है, चाहे वह रेल हो या सिनात्रा। कुछ बिंदु पर वे एक कॉल पद्धति को लागू करते हैं, सभी रूपरेखा कोड के माध्यम से काम करते हैं, और अंत में एक प्रतिक्रिया वापस करते हैं ठेठ [स्थिति, हेडर, बॉडी] रूप में।

रूबी ऑन रेल्स में उदाहरण के लिए रैक अनुरोध उस ActionDispatch::Routing.Mapperवर्ग को हिट करता है जो इस तरह दिखता है:

module ActionDispatch
  module Routing
    class Mapper
      ...
      def initialize(app, constraints, request)
        @app, @constraints, @request = app, constraints, request
      end

      def matches?(env)
        req = @request.new(env)
        ...
        return true
      end

      def call(env)
        matches?(env) ? @app.call(env) : [ 404, {'X-Cascade' => 'pass'}, [] ]
      end
      ...
  end
end

तो मूल रूप से रेल चेक, अगर किसी भी मार्ग से मेल खाता है, तो env हैश पर निर्भर करता है। यदि ऐसा है, तो यह प्रतिक्रिया की गणना करने के लिए आवेदन पर env हैश को पास करता है, अन्यथा यह तुरंत 404 के साथ प्रतिक्रिया करता है। इसलिए कोई भी वेबसर्वर जो कि रैक इंटरफेस सम्मेलन के अनुरूप है, एक पूरी तरह से विकसित की गई अनुप्रयोग सेवा देने में सक्षम है।

मध्यस्थ

रैक मिडलवेयर परतों के निर्माण का भी समर्थन करता है। वे मूल रूप से एक अनुरोध को रोकते हैं, इसके साथ कुछ करते हैं और इसे पास करते हैं। यह बहुमुखी कार्यों के लिए बहुत उपयोगी है।

मान लीजिए कि हम अपने JSON सर्वर में लॉगिंग जोड़ना चाहते हैं जो यह भी मापता है कि अनुरोध कितना समय लेता है। हम बस एक मिडलवेयर लकड़हारा बना सकते हैं जो ठीक यही करता है:

class RackLogger
  def initialize(app)
    @app = app
  end

  def call(env)
    @start = Time.now
    @status, @headers, @body = @app.call(env)
    @duration = ((Time.now - @start).to_f * 1000).round(2)

    puts "#{env['REQUEST_METHOD']} #{env['REQUEST_PATH']} - Took: #{@duration} ms"
    [@status, @headers, @body]
  end
end

जब यह बन जाता है, तो यह वास्तविक रैक अनुप्रयोग की एक प्रति खुद को बचाता है। हमारे मामले में यह हमारे JSONServer का एक उदाहरण है। रैक स्वचालित रूप से मिडलवेयर पर कॉल विधि को कॉल करता है और [status, headers, body]हमारे JSONServer रिटर्न की तरह ही एक सरणी की अपेक्षा करता है।

तो इस मिडलवेयर में, स्टार्ट पॉइंट लिया जाता है, फिर JSONServer के साथ वास्तविक कॉल किया जाता है @app.call(env), फिर लकड़हारा लॉगिंग एंट्री को आउटपुट करता है और अंत में रिस्पॉन्स के रूप में देता है [@status, @headers, @body]।

हमारे छोटे रैकअप को इस मिडलवेयर का उपयोग करने के लिए, इस तरह से एक रैक रैकर का उपयोग करें:

class JSONServer
  def call(env)
    [200, {"Content-Type" => "application/json"}, ['{ "message" : "Hello!" }']]
  end
end

class RackLogger
  def initialize(app)
    @app = app
  end

  def call(env)
    @start = Time.now
    @status, @headers, @body = @app.call(env)
    @duration = ((Time.now - @start).to_f * 1000).round(2)

    puts "#{env['REQUEST_METHOD']} #{env['REQUEST_PATH']} - Took: #{@duration} ms"
    [@status, @headers, @body]
  end
end

use RackLogger

map '/hello.json' do
  run JSONServer.new
end   

सर्वर और वॉइला को पुनरारंभ करें, यह हर अनुरोध पर एक लॉग आउटपुट करता है। रैक आपको उन कई मिडलवार्स को जोड़ने की अनुमति देता है जिन्हें उस क्रम में कहा जाता है जो वे जोड़े जाते हैं। यह रैक अनुप्रयोग के मूल को बदले बिना कार्यक्षमता जोड़ने का एक शानदार तरीका है।

रैक - मणि

हालांकि रैक - सबसे पहले - एक सम्मेलन है यह एक रत्न भी है जो महान कार्यक्षमता प्रदान करता है। उनमें से एक हम पहले से ही हमारे JSON सर्वर, रैकअप कमांड के लिए उपयोग करते थे। लेकिन वहाँ अधिक है! रैक मणि बहुत सारे उपयोग के मामलों के लिए छोटे अनुप्रयोग प्रदान करता है, जैसे कि स्थिर फाइलें या संपूर्ण निर्देशिकाओं की सेवा। आइए देखें कि हम एक साधारण फ़ाइल की सेवा कैसे करते हैं, उदाहरण के लिए HTML / index.html पर स्थित एक बहुत ही मूल HTML फ़ाइल:

<!DOCTYPE HTML>
  <html>
  <head>
    <title>The Index</title>
  </head>

  <body>
    <p>Index Page</p>
  </body>
</html>

हम शायद वेबसाइट रूट से इस फाइल को परोसना चाहते हैं, तो चलिए निम्नलिखित को हमारे config.ru में जोड़ें:

map '/' do
  run Rack::File.new "htmls/index.html"
end

अगर हम यात्रा http://localhost:9292करते हैं तो हम अपनी html फाइल को पूरी तरह से प्रस्तुत करते हैं। यह आसान था, है ना?

चलो जावास्क्रिप्ट / जावास्क्रिप्ट के तहत कुछ जावास्क्रिप्ट फ़ाइलें बनाकर और config.ru में निम्नलिखित जोड़कर जावास्क्रिप्ट फ़ाइलों की एक पूरी निर्देशिका जोड़ें:

map '/javascripts' do
  run Rack::Directory.new "javascripts"
end

सर्वर को पुनरारंभ करें और जाएँ http://localhost:9292/javascriptऔर आप सभी जावास्क्रिप्ट फ़ाइलों की एक सूची देखेंगे, जिन्हें आप अब कहीं से भी सीधे शामिल कर सकते हैं।

Comments

लेकिन रैक मिडलवेयर नहीं?

— Rup

यदि आप नहीं जानते कि रैक क्या है, तो आपको पता चल जाएगा कि यह ब्लॉग पोस्ट पढ़ने के बाद क्या है और इसका उपयोग कैसे करना है। बहुत अच्छा। विडंबना यह है कि हालांकि, पोस्ट के अंत में आधिकारिक रैक प्रलेखन के लिए लिंक उपलब्ध नहीं है!

— कॉलिन

आपका अधिकार, धन्यवाद। मैंने पोस्ट में सामग्रियों को शामिल किया और मृत लिंक को हटा दिया।

— थॉमस फनकौसर जूल

मैं कहूंगा कि यह एक सम्मेलन नहीं है। यह एक इंटरफेस है, एक अनुरोध-प्रतिक्रिया मॉडल के लिए अच्छी तरह से परिभाषित अनुबंध

— रॉन क्लेन

Answer 3

मुझे एक अच्छी राशि के लिए रैक को समझने में समस्या थी। मैंने केवल इस लघु रूबी वेब सर्वर को बनाने पर काम करने के बाद इसे पूरी तरह से समझा । मैंने अपने ब्लॉग पर रैक (कहानी के रूप में) के बारे में अपनी सीख साझा की है: http://gauravchande.com/what-is-rack-in-ruby-rails

प्रतिक्रिया स्वागत से अधिक है।

Comments

स्टैक ओवरफ्लो पर लिंक-ओनली उत्तर हतोत्साहित किए जाते हैं , क्योंकि यदि लिंक भविष्य में अनुपलब्ध हो जाता है, तो उत्तर बेकार हो जाता है। कृपया कम से कम अपने ब्लॉग पोस्ट के प्रासंगिक बिंदुओं को संक्षेप में लिखें और उन्हें इस उत्तर में जोड़ें।

पोस्ट के लिए धन्यवाद। मैं एक बहुत ही शुरुआती रेल्स प्रोग्रामर हूं और मैंने आपकी स्पष्ट पोस्ट के साथ रैक कॉन्सेप्ट को समझा।

— एडुआर्डो रामोस

महान ब्लॉग पोस्ट। अन्य उत्तर कुछ अधिक जटिल IMO लगते हैं।

— क्लैम

क्या कमाल की व्याख्या है। धन्यवाद, गौरव

— रोवितुल्ली

Answer 4

config.ru न्यूनतम चल उदाहरण

app = Proc.new do |env|
  [
    200,
    {
      'Content-Type' => 'text/plain'
    },
    ["main\n"]
  ]
end

class Middleware
  def initialize(app)
    @app = app
  end

  def call(env)
    @status, @headers, @body = @app.call(env)
    [@status, @headers, @body << "Middleware\n"]
  end
end

use(Middleware)

run(app)

दौड़ें rackupऔर जाएँ localhost:9292। आउटपुट है:

main
Middleware

तो यह स्पष्ट है कि Middlewareमुख्य ऐप को लपेटता है और कॉल करता है। इसलिए यह अनुरोध को पूर्व-संसाधित करने में सक्षम है, और किसी भी तरह से प्रतिक्रिया को पोस्ट-प्रोसेस करता है।

जैसा कि यहां बताया गया है: http://guides.rubyonrails.org/rails_on_rack.html#action-dispatcher-middleware-stack , रेल बहुत सारी कार्यक्षमता के लिए रैक बिचौलियों का उपयोग करती है, और आप स्वयं को config.middleware.useपरिवार के तरीकों से भी जोड़ सकते हैं ।

एक मिडलवेयर में कार्यक्षमता को लागू करने का लाभ यह है कि आप इसे किसी भी रैक ढांचे पर पुनः उपयोग कर सकते हैं, इस प्रकार सभी प्रमुख रूबी, और न केवल रेल।

Answer 5

रैक मिडलवेयर आपके आवेदन में आने वाले अनुरोध और प्रतिक्रिया को फ़िल्टर करने का एक तरीका है। एक मिडिलवेयर घटक क्लाइंट और सर्वर के बीच बैठता है, इनबाउंड अनुरोधों और आउटबाउंड प्रतिक्रियाओं को संसाधित करता है, लेकिन यह इंटरफ़ेस से अधिक है जिसका उपयोग वेब सर्वर से बात करने के लिए किया जा सकता है। इसका उपयोग समूह और ऑर्डर मॉड्यूल के लिए किया जाता है, जो आमतौर पर रूबी वर्ग होते हैं, और उनके बीच निर्भरता निर्दिष्ट करते हैं। रैक मिडलवेयर मॉड्यूल केवल होना चाहिए: - कंस्ट्रक्टर है जो पैरामीटर के रूप में स्टैक में अगला एप्लिकेशन लेता है - "कॉल" विधि का जवाब दें, जो कि पर्यावरण हैश को एक पैरामीटर के रूप में लेता है। इस कॉल से रिटर्निंग वैल्यू का एक प्रकार है: स्थिति कोड, पर्यावरण हैश और प्रतिक्रिया निकाय।

Answer 6

मैंने कुछ समस्याओं को हल करने के लिए रैक मिडलवेयर का उपयोग किया है:

1. कस्टम रैक रैकवेयर के साथ JSON पार्स त्रुटियों को पकड़ना और जब क्लाइंट सबमैंस JSON का पर्दाफाश करता है तो अच्छी तरह से स्वरूपित त्रुटि संदेश वापस करना
2. रैक के माध्यम से सामग्री संपीड़न :: Deflater

इसने दोनों मामलों में बहुत सुंदर सुधार किए।

Comments

यह उत्तर, जबकि कुछ उपयोगी है, वास्तव में रैक मिडलवेयर क्या है के सवाल को संबोधित नहीं करता है ।

इसके अलावा यह काफी हद तक एक ही उत्तर है ...: पी

— स्मार

Answer 7

रैक क्या है?

रूबी रूबी और रूबी ढांचे का समर्थन करने वाले webservers के बीच एक न्यूनतम इंटरफ़ेस प्रदान करता है।

रैक का उपयोग करके आप एक रैक एप्लीकेशन लिख सकते हैं।

रैक आपके रैक अनुप्रयोग के लिए पर्यावरण हैश (एक हैश, एक क्लाइंट से HTTP अनुरोध के साथ, सीजीआई-जैसे हेडर से मिलकर) पास करेगा जो इस हैश में निहित चीजों का उपयोग कर सकता है जो भी वह चाहता है।

एक रैक अनुप्रयोग क्या है?

रैक का उपयोग करने के लिए, आपको एक 'ऐप' प्रदान करना होगा - एक ऑब्जेक्ट जो कि #callपर्यावरण हैश के साथ एक पैरामीटर (आमतौर पर परिभाषित env) के रूप में विधि का जवाब देता है । #callठीक तीन मानों का एक सरणी वापस करना चाहिए:

• स्थिति कोड (जैसे '200'),
• एक हेडर के हैश ,
• प्रतिक्रिया शरीर (जो, रूबी विधि का जवाब देना होगा each)।

आप एक रैक एप्लिकेशन लिख सकते हैं जो इस तरह की एक सरणी देता है - यह आपके क्लाइंट को वापस भेजा जाएगा, रैक द्वारा, एक रिस्पांस के अंदर (यह वास्तव में कक्षा का एक उदाहरण होगा Rack::Response[डॉक्स पर जाने के लिए क्लिक करें])।

एक बहुत ही सरल रैक आवेदन:

• gem install rack
• एक config.ruफ़ाइल बनाएँ - रैक इसके लिए देखना जानता है।

हम एक छोटी रैक एप्लीकेशन बनाएंगे जो एक रिस्पॉन्स (एक उदाहरण Rack::Response) लौटाता है जो एक रिस्पांस बॉडी एक सरणी है जिसमें एक स्ट्रिंग है "Hello, World!":।

हम कमांड का उपयोग करके एक स्थानीय सर्वर को आग लगा देंगे rackup।

हमारे ब्राउज़र में संबंधित पोर्ट पर जाने पर हम "हैलो, वर्ल्ड!" देखेंगे। व्यूपोर्ट में प्रदान किया गया।

#./message_app.rb
class MessageApp
  def call(env)
    [200, {}, ['Hello, World!']]
  end
end

#./config.ru
require_relative './message_app'

run MessageApp.new

स्थानीय सर्वर के साथ लोकलहोस्ट परrackup जाएँ और 9292 पर जाएँ और आपको 'हेलो, वर्ल्ड!' देखना चाहिए। प्रदान की गई।

यह एक व्यापक व्याख्या नहीं है, लेकिन अनिवार्य रूप से यहां क्या होता है कि क्लाइंट (ब्राउज़र) अपने स्थानीय सर्वर के माध्यम से रैक के लिए एक HTTP अनुरोध भेजता है, और रैक तत्काल करता है MessageAppऔर चलाता है call, पर्यावरण हैश में विधि में एक पैरामीटर के रूप में गुजरता है () envतर्क)।

रैक रिटर्न मान (एरे) लेता है और इसका एक उदाहरण बनाने के लिए उपयोग करता है Rack::Responseऔर क्लाइंट को वापस भेजता है। ब्राउज़र का उपयोग करता जादू मुद्रित करने के लिए 'नमस्कार, दुनिया!' स्क्रीन पर।

संयोग से, अगर आप यह देखना चाहते हैं कि पर्यावरण हैश कैसा दिखता है, तो बस puts envनीचे रखें def call(env)।

जैसा कि आपने यहाँ लिखा है, मिनिमल एक रैक एप्लीकेशन है!

एक रैक अनुप्रयोग बनाना आने वाले पर्यावरण हैश के साथ बातचीत

हमारे छोटे रैक ऐप में, हम envहैश के साथ बातचीत कर सकते हैं ( पर्यावरण हैश के बारे में अधिक जानकारी के लिए यहां देखें )।

हम उपयोगकर्ता के लिए अपने स्वयं के क्वेरी स्ट्रिंग को URL में इनपुट करने की क्षमता को लागू करेंगे, इसलिए, वह स्ट्रिंग HTTP अनुरोध में मौजूद होगी, जो पर्यावरण हैश के प्रमुख / मूल्य जोड़े में से एक में मान के रूप में समझाया गया है।

हमारा रैक ऐप पर्यावरण हैश से उस क्वेरी स्ट्रिंग तक पहुंच जाएगा और उस ग्राहक को वापस भेज देगा (हमारा ब्राउज़र, इस मामले में) बॉडी इन द रिस्पॉन्स के माध्यम से।

पर्यावरण हैश पर रैक डॉक्स से: "QUERY_STRING: अनुरोध URL का वह भाग जो निम्नानुसार है; यदि कोई भी मई खाली हो सकता है, लेकिन हमेशा आवश्यक होता है!"

#./message_app.rb
class MessageApp
  def call(env)
    message = env['QUERY_STRING']
    [200, {}, [message]]
  end
end

अब, rackupऔर विज़िट करें localhost:9292?hello( ?helloक्वेरी स्ट्रिंग होने के नाते) और आपको व्यूपोर्ट में 'हैलो' को देखना चाहिए।

रैक मिडलवेयर

हम करेंगे:

• हमारे codebase में रैक मिडिलवेयर का एक टुकड़ा डालने - एक वर्ग: MessageSetter,
• पर्यावरण हैश इस वर्ग के पहले मारा जाएगा और एक पैरामीटर के रूप में पारित हो जाएगा: env,
• MessageSetter'MESSAGE'env हैश में एक कुंजी डालेगा, इसका मान 'Hello, World!'यदि env['QUERY_STRING']खाली है; env['QUERY_STRING']अगर नहीं,
• अंत में, यह वापस आ जाएगा @app.call(env)- @app'स्टैक' में अगला ऐप MessageApp:।

सबसे पहले, 'लंबे समय से हाथ' संस्करण:

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

से रैक :: बिल्डर डॉक्स हम देख Rack::Builderऔजार iteratively निर्माण रैक आवेदन करने के लिए एक छोटा सा डीएसएल। इसका मूल रूप से मतलब है कि आप एक 'स्टैक' का निर्माण कर सकते हैं जिसमें एक या एक से अधिक मिडलवार्स और एक 'निचला स्तर' है। आपके निचले स्तर के आवेदन से गुजरने वाले सभी अनुरोधों को पहले आपके मिडलवेयर (एस) द्वारा संसाधित किया जाएगा।

#useस्टैक में उपयोग करने के लिए मिडलवेयर निर्दिष्ट करता है। यह मिडिलवेयर को एक तर्क के रूप में लेता है।

रैक मिडिलवेयर होना चाहिए:

• एक कंस्ट्रक्टर है जो स्टैक में अगले एप्लिकेशन को एक पैरामीटर के रूप में लेता है।
• callएक पैरामीटर के रूप में पर्यावरण हैश लेने वाली विधि का जवाब दें ।

हमारे मामले में, 'मिडलवेयर' MessageSetter, 'कंस्ट्रक्टर' मैसेजसेटर का initializeतरीका है, स्टैक में 'अगला एप्लिकेशन' है MessageApp।

तो यहाँ, क्या की वजह से Rack::Builderहुड के नीचे होता है, appके तर्क MessageSetterकी initializeविधि है MessageApp।

(आगे बढ़ने से पहले अपना सिर ऊपर की ओर उठायें)

इसलिए, मिडलवेयर का प्रत्येक टुकड़ा अनिवार्य रूप से श्रृंखला में अगले अनुप्रयोग के लिए मौजूदा पर्यावरण हैश को 'पास' कर देता है - इसलिए आपके पास स्टैक में अगले एप्लिकेशन को पास करने से पहले मिडलवेयर के भीतर उस पर्यावरण हैश को म्यूट करने का अवसर है।

#runएक तर्क लेता है जो एक ऑब्जेक्ट है जो एक प्रतिक्रिया देता है #callऔर एक रैक प्रतिक्रिया (एक उदाहरण Rack::Response) देता है।

निष्कर्ष

उपयोग करने से Rack::Builderआप मध्यवारों की श्रृंखला का निर्माण कर सकते हैं और आपके आवेदन के लिए किसी भी अनुरोध को प्रत्येक मिडलवेयर द्वारा बदले में स्टैक में अंतिम टुकड़ा (हमारे मामले में MessageApp) संसाधित किया जाएगा । यह अत्यंत उपयोगी है क्योंकि यह प्रसंस्करण अनुरोधों के विभिन्न चरणों को अलग करता है। 'चिंताओं को अलग करने' के संदर्भ में, यह ज्यादा साफ नहीं हो सकता है!

आप एक 'अनुरोध पाइपलाइन' का निर्माण कर सकते हैं जिसमें कई मिडलवेर्स शामिल हैं जो इस तरह की चीजों से निपटते हैं:

• प्रमाणीकरण
• प्राधिकरण
• कैशिंग
• सजावट
• प्रदर्शन और उपयोग की निगरानी
• निष्पादन (वास्तव में अनुरोध को संभालना और प्रतिक्रिया प्रदान करना)

(इस थ्रेड पर एक अन्य उत्तर से ऊपर की ओर गोली)

आप इसे अक्सर पेशेवर सिनात्रा अनुप्रयोगों में देखेंगे। सिनात्रा रैक का उपयोग करता है! सिनात्रा आईएस की परिभाषा के लिए यहां देखें !

अंतिम नोट के रूप में, हमारी config.ruलघु-हाथ शैली में लिखा जा सकता है, बिल्कुल उसी कार्यक्षमता का निर्माण (और यह वही है जो आप आमतौर पर देखेंगे):

require_relative './message_app'
require_relative './middleware/message_setter'

use MessageSetter
run MessageApp.new

और अधिक स्पष्ट रूप से दिखाने के लिए कि MessageAppयह क्या कर रहा है, यहाँ इसका 'लॉन्ग-हैंड' संस्करण है जो स्पष्ट रूप से दिखाता है कि आवश्यक तीन तर्कों के साथ #callएक नया उदाहरण बना रहा Rack::Responseहै।

class MessageApp
  def call(env)
    Rack::Response.new([env['MESSAGE']], 200, {})
  end
end

उपयोगी कड़ियाँ

• इस पोस्ट के लिए पूरा कोड (Github repo प्रतिबद्ध)
• अच्छा ब्लॉग पोस्ट, "रैक मिडलवेयर का परिचय"
• कुछ अच्छे रैक प्रलेखन

Answer 8

रैक - इंटरफ़ेस b / w वेब और ऐप सर्वर

रैक एक रूबी पैकेज है जो एप्लिकेशन के साथ संचार करने के लिए एक वेब सर्वर के लिए एक इंटरफ़ेस प्रदान करता है। वेब सर्वर और ऐप के बीच मिडलवेयर घटकों को जोड़ना आसान होता है ताकि आपके अनुरोध / प्रतिक्रिया के व्यवहार को संशोधित किया जा सके। मिडिलवेयर घटक क्लाइंट और सर्वर के बीच बैठता है, इनबाउंड अनुरोधों और आउटबाउंड प्रतिक्रियाओं को संसाधित करता है।

आम शब्दों में, यह मूल रूप से एक सर्वर और रेल एप्लिकेशन (या किसी अन्य रूबी वेब ऐप) के लिए दिशानिर्देशों का एक सेट है जो एक दूसरे से बात करना चाहिए ।

रैक का उपयोग करने के लिए, एक "एप्लिकेशन" प्रदान करें: एक ऑब्जेक्ट जो कॉल विधि के लिए प्रतिक्रिया करता है, पर्यावरण हैश को एक पैरामीटर के रूप में ले रहा है, और तीन तत्वों के साथ एक एरे वापस कर रहा है:

• HTTP प्रतिक्रिया कोड
• हेडर्स का एक हश
• प्रतिक्रिया शरीर है, जो प्रत्येक का जवाब देना होगा अनुरोध ।

अधिक स्पष्टीकरण के लिए, आप नीचे दिए गए लिंक का अनुसरण कर सकते हैं।

1. https://rack.github.io/
2. https://redpanthers.co/rack-middleware/
3. https://blog.engineyard.com/2015/understanding-rack-apps-and-middleware
4. https://guides.rubyonrails.org/rails_on_rack.html#resources

रेल में, हमारे पास एक रैक फ़ाइल के रूप में config.ru है, आप rackupकमांड के साथ किसी भी रैक फ़ाइल को चला सकते हैं । और इसके लिए डिफ़ॉल्ट पोर्ट है 9292। इसका परीक्षण करने के लिए, आप बस rackupअपनी रेल निर्देशिका में दौड़ सकते हैं और परिणाम देख सकते हैं। आप उस पोर्ट को भी असाइन कर सकते हैं जिस पर आप उसे चलाना चाहते हैं। किसी भी विशिष्ट पोर्ट पर रैक फ़ाइल चलाने की आज्ञा है

rackup -p PORT_NUMBER

Answer 9

रैक एक रत्न है जो HTTP अनुरोध / प्रतिक्रिया को अमूर्त करने के लिए एक सरल इंटरफ़ेस प्रदान करता है। रैक एडॉप्टर के रूप में वेब फ्रेमवर्क (रेल, सिनात्रा आदि) और वेब सर्वर (यूनिकॉर्न, प्यूमा) के बीच बैठता है। ऊपर की छवि से यह गेंडा सर्वर पूरी तरह से स्वतंत्र रहता है रेल और रेल के बारे में जानने से गेंडा के बारे में नहीं जानता है। यह ढीली युग्मन , चिंताओं को अलग करने का एक अच्छा उदाहरण है ।

ऊपर की छवि इस रेल सम्मेलन से है रैक पर बात करें https://youtu.be/3PnUV9QzB0g मैं इसे गहरी समझ के लिए देखने की सलाह देता हूं।