Ruby on Rails 5.2 - ActionController::Live

मॉड्यूल एक्शनकंट्रोलर :: लाइव




ruby

मॉड्यूल एक्शनकंट्रोलर :: लाइव

इस मॉड्यूल को अपने कंट्रोलर में मिक्स करें, और उस कंट्रोलर की सभी क्रियाएं क्लाइंट को डेटा स्ट्रीम करने में सक्षम होंगी जैसा कि यह लिखा गया है।

class MyController < ActionController::Base
  include ActionController::Live

  def stream
    response.headers['Content-Type'] = 'text/event-stream'
    100.times {
      response.stream.write "hello world\n"
      sleep 1
    }
  ensure
    response.stream.close
  end
end

इस मॉड्यूल के साथ कुछ कैविएट हैं। प्रतिक्रिया होने के बाद आप शीर्ष लेख नहीं लिख सकते हैं (प्रतिक्रिया # प्रतिबद्ध है; सत्य वापस आ जाएगी)। प्रतिक्रिया स्ट्रीम पर write या ऑब्जेक्ट को कॉल करने से प्रतिक्रिया ऑब्जेक्ट प्रतिबद्ध हो जाएगा। सुनिश्चित करें कि सभी हेडर आपके स्ट्रीम पर लिखने या बंद करने से पहले सेट किए गए हैं।

जब आप काम पूरा कर लें, तो आपको अपनी स्ट्रीम को बंद करना होगा , अन्यथा सॉकेट हमेशा के लिए खुला रह सकता है।

अंतिम चेतावनी यह है कि आपके कार्यों को मुख्य धागे से अलग थ्रेड में निष्पादित किया जाता है। सुनिश्चित करें कि आपके कार्य थ्रेड सुरक्षित हैं, और यह कोई समस्या नहीं होनी चाहिए (थ्रेड्स, इत्यादि में राज्य साझा न करें)।

सार्वजनिक प्रवृत्ति के तरीके

log_error (अपवाद) स्रोत दिखाएं
# File actionpack/lib/action_controller/metal/live.rb, line 295
def log_error(exception)
  logger = ActionController::Base.logger
  return unless logger

  logger.fatal do
    message = "\n#{exception.class} (#{exception.message}):\n".dup
    message << exception.annoted_source_code.to_s if exception.respond_to?(:annoted_source_code)
    message << "  " << exception.backtrace.join("\n  ")
    "#{message}\n\n"
  end
end
प्रक्रिया (नाम) स्रोत दिखाएँ
# File actionpack/lib/action_controller/metal/live.rb, line 238
def process(name)
  t1 = Thread.current
  locals = t1.keys.map { |key| [key, t1[key]] }

  error = nil
  # This processes the action in a child thread. It lets us return the
  # response code and headers back up the Rack stack, and still process
  # the body in parallel with sending data to the client.
  new_controller_thread {
    ActiveSupport::Dependencies.interlock.running do
      t2 = Thread.current

      # Since we're processing the view in a different thread, copy the
      # thread locals from the main thread to the child thread. :'(
      locals.each { |k, v| t2[k] = v }

      begin
        super(name)
      rescue => e
        if @_response.committed?
          begin
            @_response.stream.write(ActionView::Base.streaming_completion_on_exception) if request.format == :html
            @_response.stream.call_on_error
          rescue => exception
            log_error(exception)
          ensure
            log_error(e)
            @_response.stream.close
          end
        else
          error = e
        end
      ensure
        @_response.commit!
      end
    end
  }

  ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
    @_response.await_commit
  end

  raise error if error
end
सुपरक्लास विधि कहता है
response_body = (शरीर) स्रोत दिखाएँ
# File actionpack/lib/action_controller/metal/live.rb, line 307
def response_body=(body)
  super
  response.close if response
end
सुपरक्लास विधि कहता है