「rails敏捷开发」 rails启动过程调研

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# The application 'railties' is installed as part of a gem, and
# this file is here to facilitate running it.
#

require 'rubygems'

version = ">= 0.a"

str = ARGV.first
if str
  str = str.b[/\A_(.*)_\z/, 1]
  if str and Gem::Version.correct?(str)
    version = str
    ARGV.shift
  end
end

if Gem.respond_to?(:activate_bin_path)
load Gem.activate_bin_path('railties', 'rails', version)
else
gem "railties", version
load Gem.bin_path("railties", "rails", version)
end

1
2
3
4
5
6
7
8
9
10
#!/usr/bin/env ruby
# frozen_string_literal: true

git_path = File.expand_path("../../.git", __dir__)

if File.exist?(git_path)
  railties_path = File.expand_path("../lib", __dir__)
  $:.unshift(railties_path)
end
require "rails/cli"

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# frozen_string_literal: true

require "rails/app_loader"

# If we are inside a Rails application this method performs an exec and thus
# the rest of this script is not run.
Rails::AppLoader.exec_app

require "rails/ruby_version_check"
Signal.trap("INT") { puts; exit(1) }

require "rails/command"

if ARGV.first == "plugin"
  ARGV.shift
  Rails::Command.invoke :plugin, ARGV
else
  Rails::Command.invoke :application, ARGV
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
def exec_app
    original_cwd = Dir.pwd

    loop do
        if exe = find_executable
            contents = File.read(exe)

            if /(APP|ENGINE)_PATH/.match?(contents)
                exec RUBY, exe, *ARGV
                break # non reachable, hack to be able to stub exec in the test suite
            elsif exe.end_with?("bin/rails") && contents.include?("This file was generated by Bundler")
                $stderr.puts(BUNDLER_WARNING)
                Object.const_set(:APP_PATH, File.expand_path("config/application", Dir.pwd))
                require File.expand_path("../boot", APP_PATH)
                require "rails/commands"
                break
            end
        end


        # If we exhaust the search there is no executable, this could be a
        # call to generate a new application, so restore the original cwd.
        Dir.chdir(original_cwd) && return if Pathname.new(Dir.pwd).root?

        # Otherwise keep moving upwards in search of an executable.
        Dir.chdir("..")
    end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# frozen_string_literal: true

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# Receives a namespace, arguments, and the behavior to invoke the command.
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

    command_name, namespace = "help", "help" if command_name.blank? || HELP_MAPPINGS.include?(command_name)
    command_name, namespace, args = "application", "application", ["--help"] if rails_new_with_no_path?(args)
    command_name, namespace = "version", "version" if %w( -v --version ).include?(command_name)

    original_argv = ARGV.dup
    ARGV.replace(args)

    command = find_by_namespace(namespace, command_name)
    if command && command.all_commands[command_name]
        command.perform(command_name, args, config)
    else
        args = ["--describe", full_namespace] if HELP_MAPPINGS.include?(args[0])
        find_by_namespace("rake").perform(full_namespace, args, config)
    end
    ensure
    ARGV.replace(original_argv)
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def perform
    extract_environment_option_from_argument
    set_application_directory!
    prepare_restart

    Rails::Server.new(server_options).tap do |server|
        # Require application after server sets environment to propagate
        # the --environment option.
        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(options[:using])
        end
    end
end

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

require "bundler/setup" # Set up gems listed in the Gemfile.
require "bootsnap/setup" # Speed up boot time by caching expensive operations.             

1
2
3
4
5
6
7
8
9
10
def start(after_stop_callback = nil)
    trap(:INT) { exit }
    create_tmp_directories
    setup_dev_caching
    log_to_stdout if options[:log_stdout]

    super()
    ensure
    after_stop_callback.call if after_stop_callback
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
def start(&block)
    if options[:warn]
        $-w = true
    end

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

    Array(options[:require]).each do |library|
        require library
    end

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

    check_pid! if options[:pid]
    
    # Touch the wrapped app, so that the config.ru is loaded before
    # daemonization (i.e. before chdir, etc).
    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, &block)
end

1
2
3
4
5
6
# This file is used by Rack-based servers to start the application.

require_relative "config/environment"

run Rails.application
Rails.application.load_server

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
def self.get(server)
    return unless server
    server = server.to_s

    unless @handlers.include? server
        load_error = try_require('rack/handler', server)
    end

    if klass = @handlers[server]
        const_get(klass)
    else
        const_get(server, false)
    end

rescue NameError => name_error
    raise load_error || name_error
end

# Select first available Rack handler given an `Array` of server names.
# Raises `LoadError` if no handler was found.
#
#   > pick ['thin', 'webrick']
#   => Rack::Handler::WEBrick
def self.pick(server_names)
    server_names = Array(server_names)
    server_names.each do |server_name|
        begin
            return get(server_name.to_s)
        rescue LoadError, NameError
        end
    end

    raise LoadError, "Couldn't find handler for: #{server_names.join(', ')}."
end

SERVER_NAMES = %w(puma thin falcon webrick).freeze
private_constant :SERVER_NAMES

def self.default
    # Guess.
    if ENV.include?("PHP_FCGI_CHILDREN")
        Rack::Handler::FastCGI
    elsif ENV.include?(REQUEST_METHOD)
        Rack::Handler::CGI
    elsif ENV.include?("RACK_HANDLER")
        self.get(ENV["RACK_HANDLER"])
    else
        pick SERVER_NAMES
    end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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 "* Gracefully stopping, waiting for requests to finish"
        launcher.stop
        puts "* Goodbye!"
    end
end