An Engine
with the responsibility of coordinating the whole boot process.
Rails::Application
is responsible for executing all railties and engines initializers. It also executes some bootstrap initializers (check Rails::Application::Bootstrap
) and finishing initializers, after all the others are executed (check Rails::Application::Finisher
).
Configuration
Besides providing the same configuration as Rails::Engine
and Rails::Railtie
, the application object has several specific configurations, for example “cache_classes”, “consider_all_requests_local”, “filter_parameters”, “logger” and so forth.
Check Rails::Application::Configuration
to see them all.
The application object is also responsible for holding the routes and reloading routes whenever the files change in development.
The Application
is also responsible for building the middleware stack.
The application is also responsible for setting up and executing the booting process. From the moment you require “config/application.rb” in your app, the booting process goes like this:
1) require "config/boot.rb" to set up load paths 2) require railties and engines 3) Define Rails.application as "class MyApp::Application < Rails::Application" 4) Run config.before_configuration callbacks 5) Load config/environments/ENV.rb 6) Run config.before_initialize callbacks 7) Run Railtie#initializer defined by railties, engines and application. One by one, each engine sets up its load paths, routes and runs its config/initializers/* files. 8) Custom Railtie#initializers added by railties, engines and applications are executed 9) Build the middleware stack and run to_prepare callbacks 10) Run config.before_eager_load and eager_load! if eager_load is true 11) Run config.after_initialize callbacks
# File railties/lib/rails/application.rb, line 81 def create(initial_variable_values = {}, &block) new(initial_variable_values, &block).run_load_hooks! end
# File railties/lib/rails/application.rb, line 85 def find_root(from) find_root_with_flag "config.ru", from, Dir.pwd end
# File railties/lib/rails/application.rb, line 70 def inherited(base) super Rails.app_class = base add_lib_to_load_path!(find_root(base.called_from)) ActiveSupport.run_load_hooks(:before_configuration, base) end
# File railties/lib/rails/application.rb, line 77 def instance super.run_load_hooks! end
# File railties/lib/rails/application.rb, line 106 def initialize(initial_variable_values = {}, &block) super() @initialized = false @reloaders = [] @routes_reloader = nil @app_env_config = nil @ordered_railties = nil @railties = nil @message_verifiers = {} @ran_load_hooks = false @executor = Class.new(ActiveSupport::Executor) @reloader = Class.new(ActiveSupport::Reloader) @reloader.executor = @executor @autoloaders = Rails::Autoloaders.new # are these actually used? @initial_variable_values = initial_variable_values @block = block end
# File railties/lib/rails/application.rb, line 221 def config_for(name, env: Rails.env) yaml = name.is_a?(Pathname) ? name : Pathname.new("#{paths["config"].existent.first}/#{name}.yml") if yaml.exist? require "erb" all_configs = ActiveSupport::ConfigurationFile.parse(yaml).deep_symbolize_keys config, shared = all_configs[env.to_sym], all_configs[:shared] if shared config = {} if config.nil? && shared.is_a?(Hash) if config.is_a?(Hash) && shared.is_a?(Hash) config = shared.deep_merge(config) elsif config.nil? config = shared end end if config.is_a?(Hash) config = ActiveSupport::OrderedOptions.new.update(config) end config else raise "Could not load configuration. No such file - #{yaml}" end end
Convenience for loading config/foo.yml for the current Rails
env.
Examples:
# config/exception_notification.yml: production: url: http://127.0.0.1:8080 namespace: my_app_production development: url: http://localhost:3001 namespace: my_app_development # config/environments/production.rb Rails.application.configure do config.middleware.use ExceptionNotifier, config_for(:exception_notification) end # You can also store configurations in a shared section which will be # merged with the environment configuration # config/example.yml shared: foo: bar: baz: 1 development: foo: bar: qux: 2 # development environment Rails.application.config_for(:example)[:foo][:bar] # => { baz: 1, qux: 2 }
# File railties/lib/rails/application.rb, line 303 def console(&blk) self.class.console(&blk) end
Sends any console called in the instance of a new application up to the console
method defined in Rails::Railtie
.
# File railties/lib/rails/application.rb, line 431 def credentials @credentials ||= encrypted(config.credentials.content_path, key_path: config.credentials.key_path) end
Decrypts the credentials hash as kept in config/credentials.yml.enc
. This file is encrypted with the Rails
master key, which is either taken from ENV["RAILS_MASTER_KEY"]
or from loading config/master.key
. If specific credentials file exists for current environment, it takes precedence, thus for production
environment look first for config/credentials/production.yml.enc
with master key taken from ENV["RAILS_MASTER_KEY"]
or from loading config/credentials/production.key
. Default behavior can be overwritten by setting config.credentials.content_path
and config.credentials.key_path
.
# File railties/lib/rails/application.rb, line 496 def eager_load! Rails.autoloaders.each(&:eager_load) end
Eager loads the application code.
# File railties/lib/rails/application.rb, line 462 def encrypted(path, key_path: "config/master.key", env_key: "RAILS_MASTER_KEY") ActiveSupport::EncryptedConfiguration.new( config_path: Rails.root.join(path), key_path: Rails.root.join(key_path), env_key: env_key, raise_if_missing_key: config.require_master_key ) end
Shorthand to decrypt any encrypted configurations or files.
For any file added with rails encrypted:edit
call read
to decrypt the file with the master key. The master key is either stored in config/master.key
or ENV["RAILS_MASTER_KEY"]
.
Rails.application.encrypted("config/mystery_man.txt.enc").read # => "We've met before, haven't we?"
It's also possible to interpret encrypted YAML files with config
.
Rails.application.encrypted("config/credentials.yml.enc").config # => { next_guys_line: "I don't think so. Where was it you think we met?" }
Any top-level configs are also accessible directly on the return value:
Rails.application.encrypted("config/credentials.yml.enc").next_guys_line # => "I don't think so. Where was it you think we met?"
The files or configs can also be encrypted with a custom key. To decrypt with a key in the ENV
, use:
Rails.application.encrypted("config/special_tokens.yml.enc", env_key: "SPECIAL_TOKENS")
Or to decrypt with a file, that should be version control ignored, relative to Rails.root
:
Rails.application.encrypted("config/special_tokens.yml.enc", key_path: "config/special_tokens.key")
# File railties/lib/rails/application.rb, line 250 def env_config @app_env_config ||= super.merge( "action_dispatch.parameter_filter" => config.filter_parameters, "action_dispatch.redirect_filter" => config.filter_redirect, "action_dispatch.secret_key_base" => secret_key_base, "action_dispatch.show_exceptions" => config.action_dispatch.show_exceptions, "action_dispatch.show_detailed_exceptions" => config.consider_all_requests_local, "action_dispatch.log_rescued_responses" => config.action_dispatch.log_rescued_responses, "action_dispatch.logger" => Rails.logger, "action_dispatch.backtrace_cleaner" => Rails.backtrace_cleaner, "action_dispatch.key_generator" => key_generator, "action_dispatch.http_auth_salt" => config.action_dispatch.http_auth_salt, "action_dispatch.signed_cookie_salt" => config.action_dispatch.signed_cookie_salt, "action_dispatch.encrypted_cookie_salt" => config.action_dispatch.encrypted_cookie_salt, "action_dispatch.encrypted_signed_cookie_salt" => config.action_dispatch.encrypted_signed_cookie_salt, "action_dispatch.authenticated_encrypted_cookie_salt" => config.action_dispatch.authenticated_encrypted_cookie_salt, "action_dispatch.use_authenticated_cookie_encryption" => config.action_dispatch.use_authenticated_cookie_encryption, "action_dispatch.encrypted_cookie_cipher" => config.action_dispatch.encrypted_cookie_cipher, "action_dispatch.signed_cookie_digest" => config.action_dispatch.signed_cookie_digest, "action_dispatch.cookies_serializer" => config.action_dispatch.cookies_serializer, "action_dispatch.cookies_digest" => config.action_dispatch.cookies_digest, "action_dispatch.cookies_rotations" => config.action_dispatch.cookies_rotations, "action_dispatch.cookies_same_site_protection" => coerce_same_site_protection(config.action_dispatch.cookies_same_site_protection), "action_dispatch.use_cookies_with_metadata" => config.action_dispatch.use_cookies_with_metadata, "action_dispatch.content_security_policy" => config.content_security_policy, "action_dispatch.content_security_policy_report_only" => config.content_security_policy_report_only, "action_dispatch.content_security_policy_nonce_generator" => config.content_security_policy_nonce_generator, "action_dispatch.content_security_policy_nonce_directives" => config.content_security_policy_nonce_directives, "action_dispatch.permissions_policy" => config.permissions_policy, ) end
Stores some of the Rails
initial environment parameters which will be used by middlewares and engines to configure themselves.
# File railties/lib/rails/application.rb, line 309 def generators(&blk) self.class.generators(&blk) end
Sends any generators called in the instance of a new application up to the generators
method defined in Rails::Railtie
.
# File railties/lib/rails/application.rb, line 129 def initialized? @initialized end
Returns true if the application is initialized.
# File railties/lib/rails/application.rb, line 291 def initializer(name, opts = {}, &block) self.class.initializer(name, opts, &block) end
Sends the initializers to the initializer
method defined in the Rails::Initializable
module. Each Rails::Application
class has its own set of initializers, as defined by the Initializable
module.
# File railties/lib/rails/application.rb, line 320 def isolate_namespace(mod) self.class.isolate_namespace(mod) end
Sends the isolate_namespace
method up to the class method.
# File railties/lib/rails/application.rb, line 153 def key_generator # number of iterations selected based on consultation with the google security # team. Details at https://github.com/rails/rails/pull/6952#issuecomment-7661220 @caching_key_generator ||= ActiveSupport::CachingKeyGenerator.new( ActiveSupport::KeyGenerator.new(secret_key_base, iterations: 1000) ) end
Returns the application's KeyGenerator
# File railties/lib/rails/application.rb, line 179 def message_verifier(verifier_name) @message_verifiers[verifier_name] ||= begin secret = key_generator.generate_key(verifier_name.to_s) ActiveSupport::MessageVerifier.new(secret) end end
Returns a message verifier object.
This verifier can be used to generate and verify signed messages in the application.
It is recommended not to use the same verifier for different things, so you can get different verifiers passing the verifier_name
argument.
verifier_name
- the name of the message verifier.
message = Rails.application.message_verifier('sensitive_data').generate('my sensible data') Rails.application.message_verifier('sensitive_data').verify(message) # => 'my sensible data'
See the ActiveSupport::MessageVerifier
documentation for more information.
# File railties/lib/rails/application.rb, line 284 def rake_tasks(&block) self.class.rake_tasks(&block) end
If you try to define a set of Rake tasks on the instance, these will get passed up to the Rake tasks defined on the application's class.
# File railties/lib/rails/application.rb, line 148 def reload_routes! routes_reloader.reload! end
Reload application routes regardless if they changed or not.
# File railties/lib/rails/application.rb, line 297 def runner(&blk) self.class.runner(&blk) end
Sends any runner called in the instance of a new application up to the runner
method defined in Rails::Railtie
.
# File railties/lib/rails/application.rb, line 414 def secret_key_base if Rails.env.development? || Rails.env.test? secrets.secret_key_base ||= generate_development_secret else validate_secret_key_base( ENV["SECRET_KEY_BASE"] || credentials.secret_key_base || secrets.secret_key_base ) end end
The secret_key_base
is used as the input secret to the application's key generator, which in turn is used to create all MessageVerifiers/MessageEncryptors, including the ones that sign and encrypt cookies.
In development and test, this is randomly generated and stored in a temporary file in tmp/development_secret.txt
.
In all other environments, we look for it first in ENV, then credentials.secret_key_base, and finally secrets.secret_key_base. For most applications, the correct place to store it is in the encrypted credentials file.
# File railties/lib/rails/application.rb, line 389 def secrets @secrets ||= begin secrets = ActiveSupport::OrderedOptions.new files = config.paths["config/secrets"].existent files = files.reject { |path| path.end_with?(".enc") } unless config.read_encrypted_secrets secrets.merge! Rails::Secrets.parse(files, env: Rails.env) # Fallback to config.secret_key_base if secrets.secret_key_base isn't set secrets.secret_key_base ||= config.secret_key_base secrets end end
# File railties/lib/rails/application.rb, line 315 def server(&blk) self.class.server(&blk) end
Sends any server called in the instance of a new application up to the server
method defined in Rails::Railtie
.
# File railties/lib/rails/application.rb, line 574 def validate_secret_key_base(secret_key_base) if secret_key_base.is_a?(String) && secret_key_base.present? secret_key_base elsif secret_key_base raise ArgumentError, "`secret_key_base` for #{Rails.env} environment must be a type of String`" else raise ArgumentError, "Missing `secret_key_base` for '#{Rails.env}' environment, set this string with `bin/rails credentials:edit`" end end
© 2004–2021 David Heinemeier Hansson
Licensed under the MIT License.