How is the request processing cycle organized in Ruby…

Web server (e.g., Puma, Unicorn): Handles incoming HTTP requests.
Rack: Interface between the web server and the Rails application. The web server wraps the request in a Rack object (Rack environment), which is passed to the Rails application.
Rails Application: Inside the Rack interface, the Rails application processes the request. Main stages:
- Middleware Stack: A set of middleware that performs various tasks before and after request processing (e.g., routing, parameter parsing, caching, session management).
- Router: Determines which controller and action should handle the request based on URL and HTTP method.
- Dispatcher: Routes the request to the found controller and action.
- Controller: Executes business logic. Can interact with models (for data handling) and render views.
- Views: Templates generate HTML, JSON, or other response formats. Can use template engines (ERB, Haml, Slim).
- Response: The controller creates a response object that includes HTTP status, headers, and body.
Return through Middleware Stack: The response object passes back through the middleware stack for final processing.
Rack: Converts the Rails response object into a format understood by the web server.
Web server: Sends the generated HTTP response to the client.

# Approximate flow in Rails pseudocode

module Rails
  class Application
    def call(env) # env is the Rack environment
      # Middleware Stack (simplified)
      # Rails::Rack::Logger.new.call(env) -> ... -> Rails::Rack::Failsafe.new.call(env)

      # Routing
      request = ActionDispatch::Request.new(env)
      route = Rails.application.routes.recognize(request) # Finds the matching route

      # Dispatching
      controller_class = route[:controller].classify.constantize # Gets the controller class
      controller_instance = controller_class.new

      # Executing the action
      response = controller_instance.process(route[:action], request) # Calls the controller action

      # Return through Middleware
      # ... (backward pass through middleware)

      response.to_a # Converts the response to Rack format [status, headers, body]
    end
  end
end

How is the request processing cycle organized in Ruby on Rails?