🚵🏻 ➕ 🍔 रैक में त्वरित प्रवेश 🤾🏻 🌝 ☦️

रैक क्या है?

रैक मणि के लेखक क्रिश्चियन न्यूकिर्चेन के अनुसार, यह रूबी (WEBrick, Mongrel, आदि) और रूबी वेब फ्रेमवर्क (रेल, सिनात्रा, आदि) का समर्थन करने वाले वेब सर्वर को जोड़ने के लिए एक न्यूनतम एपीआई प्रदान करने के लिए बनाया गया था।

फ्रेमवर्क जैसे सिनात्रा को रैक के ऊपर बनाया गया है, या उनके पास एक रैक इंटरफ़ेस है जो वेब एप्लिकेशन सर्वर को उनसे कनेक्ट करने की अनुमति देता है।

रैक का उद्देश्य सरल है - यह HTTP अनुरोधों को संभालना आसान बनाता है।

HTTP एक साधारण प्रोटोकॉल है: यह मूल रूप से उस डेटा के प्रारूप का वर्णन करता है जो सर्वर को भेजा जाता है और जिसे क्लाइंट को वापस कर दिया जाता है। HTTP अनुरोध और HTTP प्रतिक्रिया में एक समान संरचना है। एक HTTP अनुरोध एक ट्रिपल-मेथड-रिसोर्स जोड़ी, हेडर का एक सेट और एक अनुरोध निकाय है, जबकि एक HTTP HTTP प्रतिक्रिया में एक प्रतिक्रिया कोड, हेडर का एक सेट और एक वैकल्पिक प्रतिक्रिया बॉडी होती है।

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

रैक में हैंडलर और एडेप्टर शामिल हैं। पूर्व इसे रूबी वेब सर्वर से जोड़ता है, बाद में फ्रेमवर्क से जुड़ता है।

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

प्रलेखन

rack.rubyforge.org/doc

रैक स्थापित करें

कृपया ध्यान दें कि इस लेख में बताई गई सभी चीज़ों का परीक्षण विंडोज़ पर स्थापित 1.9.2 पर परीक्षण किया गया है ( होस्ट - मास्टर - अनुमोदन। प्रति। )

जांचें कि क्या आपके पास एक रैक स्थापित है। ऐसा करने के लिए, कंसोल खोलें:

# irb --simple-prompt
>> require 'rack'
=> true

यदि रिटर्न की आवश्यकता है, तो रैक स्थापित किया गया है। अन्यथा, आपको एक त्रुटि संदेश प्राप्त होगा:

LoadError: no such file to load -- rack

यह केवल मणि स्थापित रैक कमांड द्वारा तय किया गया है।

खरीद वस्तु का त्वरित दौरा

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

>> my_rack_proc = lambda {puts 'Rack Intro'}
=> #<Proc:0x1fc9038@(irb):2(lambda)>
>> # method call invokes the block
?> my_rack_proc.call
Rack Intro
=> nil

सबसे सरल रैक अनुप्रयोग - my_rack_proc

जैसा कि पहले ही उल्लेख किया गया है, हमारी रैक एप्लिकेशन एक ऑब्जेक्ट (क्लास नहीं) है जो कॉल विधि के प्रति प्रतिक्रिया करती है और एक तर्क लेती है - पर्यावरण ( यह पर्यावरण भी है - लगभग। ट्रांस। )। पर्यावरण को हैश वर्ग का एक उदाहरण होना चाहिए। एक एप्लिकेशन को तीन मानों की एक सरणी वापस करनी चाहिए: एक स्थिति कोड (100 से अधिक या इसके बराबर), हेडर (एक हैश), और निकाय (शरीर आमतौर पर स्ट्रिंग का एक सरणी है, एक आवेदन उदाहरण, या एक फ़ाइल है। प्रतिक्रिया शरीर को प्रत्येक विधि और आउटपुट में केवल स्ट्रिंग मानों का जवाब देना चाहिए)। हमारे नए proc ऑब्जेक्ट बनाएँ।

>> my_rack_proc = lambda { |env| [200, {}, ["Hello. The time is #{Time.now}"]] }
=> # <Proc:0x1f4c358@(irb):5(lambda)>

अब आप my_rack_proc को कॉल कर सकते हैं:

>> my_rack_proc.call({})
=> [200, {}, ["Hello. The time is 2011-10-24 09:18:56 +0530"]]

my_rack_proc हमारी एकल पंक्ति रैक है।

उपरोक्त उदाहरण में, हमने हेडर के लिए एक खाली हैश का उपयोग किया है। इसके बजाय, हेडर में कुछ इस प्रकार है:

>> my_rack_proc = lambda { |env| [200, {"Content-Type" => "text/plain"}, ["Hello. The time is #{Time.now}"]] }
=> #<Proc:0x1f4c358@(irb):5(lambda)>
>> my_rack_proc.call({})
=> [200, {"Content-Type" => "text/plain"}, ["Hello. The time is 2011-10-24 09:18:56 +0530"]]

हम किसी भी हैंडलर का उपयोग करके अपना रैक एप्लिकेशन चला सकते हैं।

आइए देखें कि हमारे लिए किस प्रकार के हैंडलर उपलब्ध हैं:

>> Rack::Handler.constants
=> [:CGI, :FastCGI, :Mongrel, :EventedMongrel, :SwiftipliedMongrel, :WEBrick, :LSWS, :SCGI, :Thin]

WEBrick का उपयोग करने के लिए (डिफ़ॉल्ट रूप से WEBrick माणिक के साथ स्थापित एक सर्वर है), दर्ज करें:

>> Rack::Handler::WEBrick
=> Rack::Handler::WEBrick

इन सभी हैंडलर के पास एक रन विधि है जो एक रैक एप्लीकेशन लॉन्च करती है:

>> Rack::Handler::WEBrick.run my_rack_proc
[2011-10-24 10:00:45] INFO WEBrick 1.3.1
[2011-10-24 10:00:45] INFO ruby 1.9.2 (2011-07-09) [i386-mingw32]
[2011-10-24 10:00:45] INFO WEBrick::HTTPServer#start: pid=1788 port=80

अपने ब्राउज़र में लोकलहोस्ट पेज खोलें और आपको एक पंक्ति देखनी चाहिए:

  नमस्कार।  समय है 2011-10-24 10:02:20 +0530

नोट: यदि आपके पास पहले से ही पोर्ट 80 पर कुछ चल रहा है, तो आप एप्लिकेशन को दूसरे पोर्ट पर चला सकते हैं।

>> Rack::Handler::WEBrick.run my_rack_proc, :Port => 9876
[2011-10-24 11:32:21] INFO WEBrick 1.3.1
[2011-10-24 11:32:21] INFO ruby 1.9.2 (2011-07-09) [i386-mingw32]
[2011-10-24 11:32:21] INFO WEBrick::HTTPServer # start: pid = 480 port = 9876

एक अन्य रैक एप्लीकेशन my_method है

रैक-आवेदन जरूरी लंबोदर नहीं है। यह एक विधि भी हो सकती है।

>> def my_method env
>> [200, {}, ["method called"]]
>> end
=> nil
>> Rack::Handler::WEBrick.run method(:my_method)
[2011-10-24 14:32:05] INFO WEBrick 1.3.1
[2011-10-24 14:32:05] INFO ruby 1.9.2 (2011-07-09) [i386-mingw32]
[2011-10-24 14:32:05] INFO WEBrick::HTTPServer#start: pid=1644 port=80

लोकलहोस्ट में आप फिर से देखेंगे:

  विधि कहा जाता है

ऑब्जेक्ट ऑब्जेक्ट विधि का उपयोग करके विधि ऑब्जेक्ट बनाए जाते हैं। वे एक विशिष्ट वस्तु के साथ जुड़े हुए हैं (और न केवल एक वर्ग के साथ)। उनका उपयोग किसी वस्तु के भीतर एक विधि को कॉल करने के लिए किया जा सकता है। Method.call एक ऐसा तरीका है जो एक विधि को कॉल करता है ( ओह, हैक, हैक ... - लगभग। ) निर्दिष्ट तर्कों के साथ और उस मूल्य को वापस करता है जिसे कॉल विधि वापस आती है।

रैकअप का उपयोग करना

जेम रैक उपयोगी टुकड़ों के एक समूह के साथ आता है जो डेवलपर के जीवन को सरल बनाता है। इन टुकड़ों में से एक रैकअप है।

रैक अनुप्रयोगों को लॉन्च करने के लिए रैकअप एक उपयोगी उपकरण है। रैकअप स्वयं ही उस वातावरण को निर्धारित करता है जिसमें वह चल रहा है और आपके एप्लिकेशन को FastCGI, CGI या स्टैंड-अलोन के साथ Mongrel या WEBrick - सभी एक ही डे कॉन्फ़िगरेशन के साथ चलाता है।

रैकअप का उपयोग करने के लिए, आपको इसकी कॉन्फ़िगरेशन फ़ाइल बनानी होगी। अधिवेशन द्वारा, आपको इस विन्यास के लिए Ph एक्सटेंशन का उपयोग करना चाहिए। डिफ़ॉल्ट रूप से, पोर्ट 9292 पर रैकअप शुरू होता है।

चलो एक config.ru फ़ाइल बनाते हैं:

 run lambda { |env| [200, {"Content-Type" => "text/plain"}, ["Hello. The time is #{Time.now}"]] }

इस फ़ाइल में रन शब्द होता है, जिसे .call विधि के प्रति प्रतिक्रिया करने वाली हर चीज़ से बुलाया जा सकता है।

Config.ru फ़ाइल के साथ फ़ोल्डर में रैक-अनुप्रयोग शुरू करने के लिए, दर्ज करें:

$ rackup config.ru
[2011-10-24 15:18:03] INFO WEBrick 1.3.1
[2011-10-24 15:18:03] INFO ruby 1.9.2 (2011-07-09) [i386-mingw32]
[2011-10-24 15:18:03] INFO WEBrick::HTTPServer # start: pid = 3304 port = 9292

अब, लोकलहोस्ट पर : 9292 / हमें फिर से निम्नलिखित पेज दिया जाएगा:

Hello. The time is 2011-10-24 15:18:10 +0530
चलिए हमारे एप्लिकेशन को config.ru फ़ाइल से my_app.rb पर ले जाते हैं:

 # my_app.rb class MyApp def call(env) [200, {"Content-Type" => "text/html"}, ["Hello Rack Participants"]] end end

Config.ru भी बदलें:

 require './my_app' run MyApp.new

अब आप फिर से आवेदन शुरू कर सकते हैं ("रैकअप config.ru" का उपयोग करके) और जांचें कि क्या पृष्ठ ब्राउज़र को प्रस्तुत किया गया है।

Heroku पर रैक एप्लिकेशन को तैनात करें।

(लेख का यह टुकड़ा मेरे द्वारा बेरहमी से काटा गया था, क्योंकि यह खिड़कियों पर गिट की स्थापना और हरोकू पर तैनाती का वर्णन करता है, जिसका लेख से कोई लेना-देना नहीं है। यदि आप रुचि रखते हैं, तो आप इसे मूल - अनुमानित रूप से पढ़ सकते हैं । )

रैक मिडलवेयर का उपयोग करना

यह पहले उल्लेख किया गया था कि सर्वर और ढांचे के बीच रैक को मिडलवेयर का उपयोग करके आपकी आवश्यकताओं के लिए कॉन्फ़िगर किया जा सकता है।

रैकअप एक ऐसी विधि का भी उपयोग करता है जो मिडलवेयर को स्वीकार करती है। चलो अंतर्निहित रैक मिडलवेयर में से एक का उपयोग करें।

आपने देखा होगा कि हर बार config.ru या my_app.rb फ़ाइलों को बदलने के बाद, आपको WEBrick सर्वर को पुनरारंभ करना होगा। मिडलवेयर रैक :: रीलोडर का उपयोग करके इससे बचा जा सकता है। Config.ru संपादित करें:

 require './my_app' use Rack::Reloader run MyApp.new

और my_app.rb:

 # my_app.rb class MyApp def call(env) [200, {"Content-Type" => "text/html"}, ["Hello Rack Participants from across the globe"]] end end

एप्लिकेशन लॉन्च करें और ब्राउज़र में इसके साथ पृष्ठ खोलें। अब दुनिया भर से "हैलो रैक पार्टिसिपेंट्स!" से दुनिया भर के "हैलो रैक पार्टिसिपेंट्स!" के टेक्स्ट में बदलाव करें। ब्राउजर में पेज अपडेट करने के बाद, आप वेब सर्वर को रिस्टार्ट किए बिना एडिट किए हुए टेक्स्ट को देखेंगे।

अपनी खुद की मिडलवेयर लिखना

मिडलवेयर हमेशा व्यवहार में आपके आंतरिक अनुप्रयोग को लपेटने का कार्य करता है।

आइए सरलतम मिडलवेयर बनाएं जो http प्रतिक्रिया के मुख्य भाग में पाठ जोड़ता है। ऐसा करने के लिए, MyRackMiddleware वर्ग बनाएं:

 class MyRackMiddleware def initialize(appl) @appl = appl end def call(env) end end

उपरोक्त कोड में, प्रारंभिक प्रतिक्रिया निकाय प्राप्त करने के लिए, हम MyRackMiddleware वर्ग को इनिशियलाइज़ करते हैं, इसके लिए एप्लिकेशन (appl) पास करते हैं।

अब .call विधि बदलें:

 def call(env) status, headers, body = @appl.call(env) # we now call the inner application end

उपरोक्त कोड में, हमारे पास मूल प्रतिक्रिया निकाय तक पहुंच है, जिसे अब हम बदल सकते हैं। रैक आपको गारंटी नहीं देता है कि शरीर एक स्ट्रिंग होगा। यह एक ऑब्जेक्ट भी हो सकता है, लेकिन हम जानते हैं कि जब आप .each विधि को कॉल करते हैं, तो लौटा हुआ सब कुछ एक स्ट्रिंग होगा। हम इसका उपयोग .call विधि में करते हैं:

 def call(env) status, headers, body = @appl.call(env) append_s = "... greetings from RubyLearning!!" [status, headers, body << append_s] end

अब config.ru फ़ाइल बदलें:

 require './my_app' require './myrackmiddleware' use Rack::Reloader use MyRackMiddleware run MyApp.new

हम एप्लिकेशन लॉन्च करते हैं और ब्राउज़र में आप देख सकते हैं "दुनिया भर से हैलो रैक प्रतिभागी ... RubyLearning से शुभकामनाएं!"

रैक और सिनात्रा

अंत में, यहां साइनट्रा फ्रेमवर्क के साथ रैक का उपयोग करने का एक सरल उदाहरण है।

चलो एक तुच्छ एप्लिकेशन my_sinatra.rb बनाते हैं जो रैक मिडलवेयर का उपयोग करेगा:

 require 'sinatra' require './rackmiddleware' use RackMiddleware get '/' do 'Welcome to all' end

अब चलो एक साधारण मिडलवेयर क्लास में रखते हैं जो एप्लिकेशन से अनुरोध को संसाधित करने के लिए कंसोल समय को लिखेगा। Rackmiddleware.rb फ़ाइल बनाएँ:

 class RackMiddleware def initialize(appl) @appl = appl end def call(env) start = Time.now status, headers, body = @appl.call(env) # call our Sinatra app stop = Time.now puts "Response Time: #{stop-start}" # display on console [status, headers, body] end end