module ActionController::Live

def self.live_thread_pool_executor 

def self.live_thread_pool_executor
  @live_thread_pool_executor ||= Concurrent::CachedThreadPool.new(name: "action_controller.live")
end

def clean_up_thread_locals(locals, thread) # :nodoc:

:nodoc:
Ensure we clean up any thread locals we copied so that the thread can reused. 
def clean_up_thread_locals(locals, thread) # :nodoc:
  locals.each { |k, _| thread[k] = nil }
end

def clean_up_thread_locals(*args) # :nodoc:

:nodoc: 
def clean_up_thread_locals(*args) # :nodoc:
end

def log_error(exception) 

def log_error(exception)
  logger = ActionController::Base.logger
  return unless logger
  logger.fatal do
    message = +"\n#{exception.class} (#{exception.message}):\n"
    message << exception.annotated_source_code.to_s if exception.respond_to?(:annotated_source_code)
    message << "  " << exception.backtrace.join("\n  ")
    "#{message}\n\n"
  end
end

def new_controller_thread # :nodoc:

:nodoc:
internals. Seriously!
data from the response bodies. Nobody should call this method except in Rails
fact that Rack isn't based around IOs and we need to use a thread to stream
Spawn a new thread to serve up the controller in. This is to get around the 
def new_controller_thread # :nodoc:
  ActionController::Live.live_thread_pool_executor.post do
    t2 = Thread.current
    t2.abort_on_exception = true
    yield
  end
end

def new_controller_thread # :nodoc:

:nodoc: 
def new_controller_thread # :nodoc:
  yield
end

def process(name) 

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 }
      ActiveSupport::IsolatedExecutionState.share_with(t1)
      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
        ActiveSupport::IsolatedExecutionState.clear
        clean_up_thread_locals(locals, t2)
        @_response.commit!
      end
    end
  }
  ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
    @_response.await_commit
  end
  raise error if error
end

def response_body=(body) 

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

def send_stream(filename:, disposition: "attachment", type: nil)

end
end
stream.write "#{subscriber.email_address},#{subscriber.updated_at}\n"
@subscribers.find_each do |subscriber|

stream.write "email_address,updated_at\n"
send_stream(filename: "subscribers.csv") do |stream|

Example of generating a csv export:


downloaded. Valid values are 'inline' and 'attachment' (default).
* `:disposition` - specifies whether the file will be shown inline or
default type 'application/octet-stream' will be used.
in `:filename`. If no content type is registered for the extension, the
:json. If omitted, type will be inferred from the file extension specified
or a symbol for a registered type with `Mime::Type.register`, for example
* `:type` - specifies an HTTP content type. You can specify either a string
* `:filename` - suggests a filename for the browser to use.

#### Options:

first. Similar to send_data, but where the data is generated live.
or other running data where you don't want the entire file buffered in memory
Sends a stream to the browser, which is helpful when you're generating exports 
def send_stream(filename:, disposition: "attachment", type: nil)
  payload = { filename: filename, disposition: disposition, type: type }
  ActiveSupport::Notifications.instrument("send_stream.action_controller", payload) do
    response.headers["Content-Type"] =
      (type.is_a?(Symbol) ? Mime[type].to_s : type) ||
      Mime::Type.lookup_by_extension(File.extname(filename).downcase.delete("."))&.to_s ||
      "application/octet-stream"
    response.headers["Content-Disposition"] =
      ActionDispatch::Http::ContentDisposition.format(disposition: disposition, filename: filename)
    yield response.stream
  end
ensure
  response.stream.close
end