123456789_123456789_123456789_123456789_123456789_

Module: ActionController::Live

Relationships & Source Files
Namespace Children
Modules:
ClassMethods
Classes:
SSE
Exceptions:
ClientDisconnected
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
self, ::ActiveSupport::Concern
Defined in: actionpack/lib/action_controller/metal/live.rb,
actionpack/lib/action_controller/test_case.rb

Overview

Mix this module into your controller, and all actions in that controller will be able to stream data to the client as it’s written.

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

There are a few caveats with this module. You cannot write headers after the response has been committed (Response#committed? will return truthy). Calling write or close on the response stream will cause the response object to be committed. Make sure all headers are set before calling write or close on your stream.

You must call close on your stream when you’re finished, otherwise the socket may be left open forever.

The final caveat is that your actions are executed in a separate thread than the main thread. Make sure your actions are thread safe, and this shouldn’t be a problem (don’t share state across threads, etc).

Class Method Summary

::ActiveSupport::Concern - Extended

append_features, class_methods, included

Instance Attribute Summary

Instance Method Summary

Instance Attribute Details

#response_body=(body) (writeonly)

[ GitHub ] 

  


# File 'actionpack/lib/action_controller/metal/live.rb', line 307



def response_body=(body)
  super
  response.close if response
end


  







Instance Method Details



  

    #log_error(exception)  
  

  [ GitHub ]


  

  


# 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


  








  

    #process(name)  
  

  [ GitHub ]


  

  


# 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