Rails 초기화 프로세스

#!/usr/bin/env ruby
APP_PATH = File.expand_path("../config/application", __dir__)
require_relative "../config/boot"
require "rails/commands"

ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)

require "bundler/setup" # Gemfile에 나열된 gem들을 설정합니다.
require "bootsnap/setup" # 비용이 많이 드는 작업을 캐싱하여 부팅 시간을 단축합니다.

require "rails/command"

aliases = {
  "g"  => "generate",
  "d"  => "destroy", 
  "c"  => "console",
  "s"  => "server",
  "db" => "dbconsole",
  "r"  => "runner",
  "t"  => "test"
}

command = ARGV.shift
command = aliases[command] || command

Rails::Command.invoke command, ARGV

module Rails
  module Command
    class << self
      def invoke(full_namespace, args = [], **config)
        namespace = full_namespace = full_namespace.to_s

        if char = namespace =~ /:(\w+)$/
          command_name, namespace = $1, namespace.slice(0, char) 
        else
          command_name = namespace
        end

        # 커맨드명이 비어있거나 HELP_MAPPINGS에 포함되어 있으면 help로 설정
        command_name, namespace = "help", "help" if command_name.blank? || HELP_MAPPINGS.include?(command_name)
        # -v 또는 --version 옵션이면 version으로 설정
        command_name, namespace = "version", "version" if %w( -v --version ).include?(command_name)

        command = find_by_namespace(namespace, command_name)
        if command && command.all_commands[command_name]
          command.perform(command_name, args, config) 
        else
          find_by_namespace("rake").perform(full_namespace, args, config)
        end
      end
    end
  end
end

module Rails
  module Command
    class ServerCommand < Base # :nodoc:
      def perform
        # argument에서 environment 옵션을 추출
        extract_environment_option_from_argument
        # 애플리케이션 디렉토리 설정
        set_application_directory!
        # 재시작 준비
        prepare_restart

        Rails::Server.new(server_options).tap do |server|
          # --environment 옵션을 전파하기 위해
          # 서버가 environment를 설정한 후 애플리케이션을 require
          require APP_PATH
          Dir.chdir(Rails.application.root)

          if server.serveable?
            print_boot_information(server.server, server.served_url)
            after_stop_callback = -> { say "Exiting" unless options[:daemon] }
            server.start(after_stop_callback) 
          else
            say rack_server_suggestion(using)
          end
        end
      end
    end
  end
end

module Rails
  class Server < ::Rack::Server
    def initialize(options = nil)
      @default_options = options || {}
      super(@default_options) 
      set_environment
    end
  end
end

module Rack
  class Server
    def initialize(options = nil) 
      @ignore_options = []

      if options
        @use_default_options = false 
        @options = options
        @app = options[:app] if options[:app]
      else
        argv = defined?(SPEC_ARGV) ? SPEC_ARGV : ARGV
        @use_default_options = true
        @options = parse_options(argv)
      end
    end
  end
end

module Rails
  module Command
    class ServerCommand  
      no_commands do
        def server_options
          {
            user_supplied_options: user_supplied_options,  # 사용자가 제공한 옵션 
            server:                using,                  # 사용할 서버
            log_stdout:            log_to_stdout?,        # stdout으로 로그 출력 여부
            Port:                  port,                  # 포트
            Host:                  host,                  # 호스트
            DoNotReverseLookup:    true,                 # 역방향 DNS 조회 비활성화
            config:                options[:config],      # 설정
            environment:           environment,           # 환경
            daemonize:             options[:daemon],      # 데몬 실행 여부 
            pid:                   pid,                   # PID
            caching:               options[:dev_caching], # 개발 캐싱 사용 여부
            restart_cmd:           restart_command,       # 재시작 명령어
            early_hints:           early_hints           # Early Hints 활성화 여부
          }
        end
      end
    end
  end
end

module Rails
  module Server
    def set_environment
      ENV["RAILS_ENV"] ||= options[:environment]  
    end
  end 
end

module Rails
  class Server < ::Rack::Server
    def start(after_stop_callback = nil)
      trap(:INT) { exit }
      create_tmp_directories
      setup_dev_caching
      log_to_stdout if options[:log_stdout]

      super() 
      # ...
    end

    private
      # development 환경에서 캐싱을 설정합니다
      def setup_dev_caching
        if options[:environment] == "development"
          Rails::DevCaching.enable_by_argument(options[:caching])
        end
      end

      # tmp 디렉토리들을 생성합니다
      def create_tmp_directories
        %w(cache pids sockets).each do |dir_to_make|
          FileUtils.mkdir_p(File.join(Rails.root, "tmp", dir_to_make))
        end
      end

      # STDOUT으로 로그를 출력합니다
      def log_to_stdout
        wrapped_app # 로거가 설정되도록 앱을 터치합니다

        console = ActiveSupport::Logger.new(STDOUT)
        console.formatter = Rails.logger.formatter
        console.level = Rails.logger.level

        unless ActiveSupport::Logger.logger_outputs_to?(Rails.logger, STDOUT)
          Rails.logger.extend(ActiveSupport::Logger.broadcast(console))
        end
      end
  end
end

module Rack
  class Server
    def start(&blk)
      if options[:warn]
        $-w = true
      end

      if includes = options[:include]
        $LOAD_PATH.unshift(*includes) 
      end

      if library = options[:require]
        require library
      end

      if options[:debug]
        $DEBUG = true
        p options[:server]
        pp wrapped_app
        pp app
      end

      check_pid! if options[:pid]

      # daemonization(chdir 등) 이전에 config.ru가 로드되도록 
      # wrapped app을 먼저 건드립니다.
      handle_profiling(options[:heapfile], options[:profile_mode], options[:profile_file]) do
        wrapped_app
      end

      daemonize_app if options[:daemonize]

      write_pid if options[:pid]

      trap(:INT) do
        if server.respond_to?(:shutdown)
          server.shutdown
        else
          exit
        end
      end

      server.run wrapped_app, options, &blk
    end
  end
end

module Rack
  class Server
    def wrapped_app
      @wrapped_app ||= build_app app
    end
  end
end

module Rack
  class Server
    def app
      # :builder 옵션이 있으면 문자열로부터 앱을 빌드하고 그렇지 않으면 config 파일로부터 앱과 옵션을 빌드합니다 
      @app ||= options[:builder] ? build_app_from_string : build_app_and_options_from_config
    end

    # ...

    private
      def build_app_and_options_from_config
        if !::File.exist? options[:config]
          abort "구성 파일 #{options[:config]}을 찾을 수 없습니다"
        end

        app, options = Rack::Builder.parse_file(self.options[:config], opt_parser)
        @options.merge!(options) { |key, old, new| old }
        app
      end

      def build_app_from_string
        Rack::Builder.new_from_string(self.options[:builder])
      end
  end
end

# 이 파일은 Rack 기반 서버가 애플리케이션을 시작하는 데 사용됩니다.

require_relative "config/environment"

run Rails.application

module Rack
  class Builder
    def self.load_file(path, opts = Server::Options.new)
      # ...
      app = new_from_string cfgfile, config 
      # ...  
    end

    # ...

    def self.new_from_string(builder_script, file = "(rackup)")
      eval "Rack::Builder.new {\n" + builder_script + "\n}.to_app",
        TOPLEVEL_BINDING, file, 0
    end
  end
end

require_relative "config/environment"

require_relative "application"

require_relative "boot"

require "rails/all"

require "rails"

%w(
  active_record/railtie
  active_storage/engine
  action_controller/railtie
  action_view/railtie
  action_mailer/railtie
  active_job/railtie
  action_cable/engine
  action_mailbox/engine
  action_text/engine
  rails/test_unit/railtie
).each do |railtie|
  begin
    require railtie 
  rescue LoadError
  end
end

def initialize!(group = :default) # :nodoc:
  raise "애플리케이션이 이미 초기화되었습니다." if @initialized
  run_initializers(group, self)
  @initialized = true
  self
end

def run_initializers(group = :default, *args)
  return if instance_variable_defined?(:@ran) # 이미 실행되었으면 리턴
  initializers.tsort_each do |initializer| # initializer들을 위상 정렬된 순서로 반복
    initializer.run(*args) if initializer.belongs_to?(group) # 해당 그룹에 속한 initializer만 실행
  end
  @ran = true # 실행 완료 표시
end

module Rack
  class Server
    def app
      # builder option이 있다면 문자열로부터 app을 생성하고, 
      # 그렇지 않다면 config로부터 app과 option을 생성합니다
      @app ||= options[:builder] ? build_app_from_string : build_app_and_options_from_config
    end

    # ...

    private
      def build_app_and_options_from_config
        if !::File.exist? options[:config]
          abort "설정 파일 #{options[:config]}을(를) 찾을 수 없습니다"
        end

        app, options = Rack::Builder.parse_file(self.options[:config], opt_parser)
        @options.merge!(options) { |key, old, new| old }
        app
      end

      def build_app_from_string
        Rack::Builder.new_from_string(self.options[:builder])
      end
  end
end

module Rack
  class Server
    private
      def build_app(app)
        # 설정된 environment에 대한 모든 middleware를 app에 적용합니다
        # middleware는 역순으로 순회하며 각각의 middleware는 하나씩 호출됩니다
        # middleware는 호출 가능한 객체인 경우 실행됩니다
        # 그 다음 app에 middleware를 wrapping하고 새로운 app을 반환합니다
        middleware[options[:environment]].reverse_each do |middleware|
          middleware = middleware.call(self) if middleware.respond_to?(:call)
          next unless middleware
          klass, *args = middleware
          app = klass.new(app, *args)
        end
        app
      end
  end
end

server.run wrapped_app, options, &blk

module Rack
  module Handler
    module Puma
      # ...
      def self.run(app, options = {})
        conf   = self.config(app, options) 

        events = options.delete(:Silent) ? ::Puma::Events.strings : ::Puma::Events.stdio

        launcher = ::Puma::Launcher.new(conf, events: events)

        yield launcher if block_given?
        begin
          launcher.run
        rescue Interrupt
          puts "* 안전하게 종료하는 중이며, 요청이 완료되기를 기다리는 중입니다"
          launcher.stop
          puts "* 안녕히 가세요!"
        end
      end
      # ...
    end
  end
end