зеркало из https://github.com/github/ruby.git
1345 строки
46 KiB
Plaintext
1345 строки
46 KiB
Plaintext
require "tmpdir"
|
|
require "digest/md5"
|
|
require "benchmark"
|
|
require "rubygems"
|
|
require "language_pack"
|
|
require "language_pack/base"
|
|
require "language_pack/ruby_version"
|
|
require "language_pack/helpers/nodebin"
|
|
require "language_pack/helpers/node_installer"
|
|
require "language_pack/helpers/yarn_installer"
|
|
require "language_pack/helpers/layer"
|
|
require "language_pack/helpers/binstub_check"
|
|
require "language_pack/version"
|
|
|
|
# base Ruby Language Pack. This is for any base ruby app.
|
|
class LanguagePack::Ruby < LanguagePack::Base
|
|
NAME = "ruby"
|
|
LIBYAML_VERSION = "0.1.7"
|
|
LIBYAML_PATH = "libyaml-#{LIBYAML_VERSION}"
|
|
RBX_BASE_URL = "http://binaries.rubini.us/heroku"
|
|
NODE_BP_PATH = "vendor/node/bin"
|
|
|
|
Layer = LanguagePack::Helpers::Layer
|
|
|
|
# detects if this is a valid Ruby app
|
|
# @return [Boolean] true if it's a Ruby app
|
|
def self.use?
|
|
instrument "ruby.use" do
|
|
File.exist?("Gemfile")
|
|
end
|
|
end
|
|
|
|
def self.bundler
|
|
@@bundler ||= LanguagePack::Helpers::BundlerWrapper.new.install
|
|
end
|
|
|
|
def bundler
|
|
self.class.bundler
|
|
end
|
|
|
|
def initialize(*args)
|
|
super(*args)
|
|
@fetchers[:mri] = LanguagePack::Fetcher.new(VENDOR_URL, @stack)
|
|
@fetchers[:rbx] = LanguagePack::Fetcher.new(RBX_BASE_URL, @stack)
|
|
@node_installer = LanguagePack::Helpers::NodeInstaller.new
|
|
@yarn_installer = LanguagePack::Helpers::YarnInstaller.new
|
|
end
|
|
|
|
def name
|
|
"Ruby"
|
|
end
|
|
|
|
def default_addons
|
|
instrument "ruby.default_addons" do
|
|
add_dev_database_addon
|
|
end
|
|
end
|
|
|
|
def default_config_vars
|
|
instrument "ruby.default_config_vars" do
|
|
vars = {
|
|
"LANG" => env("LANG") || "en_US.UTF-8",
|
|
}
|
|
|
|
ruby_version.jruby? ? vars.merge({
|
|
"JRUBY_OPTS" => default_jruby_opts
|
|
}) : vars
|
|
end
|
|
end
|
|
|
|
def default_process_types
|
|
instrument "ruby.default_process_types" do
|
|
{
|
|
"rake" => "bundle exec rake",
|
|
"console" => "bundle exec irb"
|
|
}
|
|
end
|
|
end
|
|
|
|
def best_practice_warnings
|
|
if bundler.has_gem?("asset_sync")
|
|
warn(<<-WARNING)
|
|
You are using the `asset_sync` gem.
|
|
This is not recommended.
|
|
See https://devcenter.heroku.com/articles/please-do-not-use-asset-sync for more information.
|
|
WARNING
|
|
end
|
|
end
|
|
|
|
def compile
|
|
instrument 'ruby.compile' do
|
|
# check for new app at the beginning of the compile
|
|
new_app?
|
|
Dir.chdir(build_path)
|
|
remove_vendor_bundle
|
|
warn_bundler_upgrade
|
|
warn_bad_binstubs
|
|
install_ruby(slug_vendor_ruby, build_ruby_path)
|
|
setup_language_pack_environment(
|
|
ruby_layer_path: File.expand_path("."),
|
|
gem_layer_path: File.expand_path("."),
|
|
bundle_path: "vendor/bundle",
|
|
bundle_default_without: "development:test"
|
|
)
|
|
allow_git do
|
|
install_bundler_in_app(slug_vendor_base)
|
|
load_bundler_cache
|
|
build_bundler
|
|
post_bundler
|
|
create_database_yml
|
|
install_binaries
|
|
run_assets_precompile_rake_task
|
|
end
|
|
config_detect
|
|
best_practice_warnings
|
|
warn_outdated_ruby
|
|
setup_profiled(ruby_layer_path: "$HOME", gem_layer_path: "$HOME") # $HOME is set to /app at run time
|
|
setup_export
|
|
cleanup
|
|
super
|
|
end
|
|
rescue => e
|
|
warn_outdated_ruby
|
|
raise e
|
|
end
|
|
|
|
|
|
def build
|
|
new_app?
|
|
remove_vendor_bundle
|
|
warn_bad_binstubs
|
|
ruby_layer = Layer.new(@layer_dir, "ruby", launch: true)
|
|
install_ruby("#{ruby_layer.path}/#{slug_vendor_ruby}")
|
|
ruby_layer.metadata[:version] = ruby_version.version
|
|
ruby_layer.metadata[:patchlevel] = ruby_version.patchlevel if ruby_version.patchlevel
|
|
ruby_layer.metadata[:engine] = ruby_version.engine.to_s
|
|
ruby_layer.metadata[:engine_version] = ruby_version.engine_version
|
|
ruby_layer.write
|
|
|
|
gem_layer = Layer.new(@layer_dir, "gems", launch: true, cache: true, build: true)
|
|
setup_language_pack_environment(
|
|
ruby_layer_path: ruby_layer.path,
|
|
gem_layer_path: gem_layer.path,
|
|
bundle_path: "#{gem_layer.path}/vendor/bundle",
|
|
bundle_default_without: "development:test"
|
|
)
|
|
allow_git do
|
|
# TODO install bundler in separate layer
|
|
topic "Loading Bundler Cache"
|
|
gem_layer.validate! do |metadata|
|
|
valid_bundler_cache?(gem_layer.path, gem_layer.metadata)
|
|
end
|
|
install_bundler_in_app("#{gem_layer.path}/#{slug_vendor_base}")
|
|
build_bundler
|
|
# TODO post_bundler might need to be done in a new layer
|
|
bundler.clean
|
|
gem_layer.metadata[:gems] = Digest::SHA2.hexdigest(File.read("Gemfile.lock"))
|
|
gem_layer.metadata[:stack] = @stack
|
|
gem_layer.metadata[:ruby_version] = run_stdout(%q(ruby -v)).strip
|
|
gem_layer.metadata[:rubygems_version] = run_stdout(%q(gem -v)).strip
|
|
gem_layer.metadata[:buildpack_version] = BUILDPACK_VERSION
|
|
gem_layer.write
|
|
|
|
create_database_yml
|
|
# TODO replace this with multibuildpack stuff? put binaries in their own layer?
|
|
install_binaries
|
|
run_assets_precompile_rake_task
|
|
end
|
|
setup_profiled(ruby_layer_path: ruby_layer.path, gem_layer_path: gem_layer.path)
|
|
setup_export(gem_layer)
|
|
config_detect
|
|
best_practice_warnings
|
|
cleanup
|
|
|
|
super
|
|
end
|
|
|
|
def cleanup
|
|
end
|
|
|
|
def config_detect
|
|
end
|
|
|
|
private
|
|
|
|
# A bad shebang line looks like this:
|
|
#
|
|
# ```
|
|
# #!/usr/bin/env ruby2.5
|
|
# ```
|
|
#
|
|
# Since `ruby2.5` is not a valid binary name
|
|
#
|
|
def warn_bad_binstubs
|
|
check = LanguagePack::Helpers::BinstubCheck.new(app_root_dir: Dir.pwd, warn_object: self)
|
|
check.call
|
|
end
|
|
|
|
def default_malloc_arena_max?
|
|
return true if @metadata.exists?("default_malloc_arena_max")
|
|
return @metadata.touch("default_malloc_arena_max") if new_app?
|
|
|
|
return false
|
|
end
|
|
|
|
def warn_bundler_upgrade
|
|
old_bundler_version = @metadata.read("bundler_version").strip if @metadata.exists?("bundler_version")
|
|
|
|
if old_bundler_version && old_bundler_version != bundler.version
|
|
warn(<<-WARNING, inline: true)
|
|
Your app was upgraded to bundler #{ bundler.version }.
|
|
Previously you had a successful deploy with bundler #{ old_bundler_version }.
|
|
|
|
If you see problems related to the bundler version please refer to:
|
|
https://devcenter.heroku.com/articles/bundler-version#known-upgrade-issues
|
|
|
|
WARNING
|
|
end
|
|
end
|
|
|
|
# For example "vendor/bundle/ruby/2.6.0"
|
|
def self.slug_vendor_base
|
|
@slug_vendor_base ||= begin
|
|
command = %q(ruby -e "require 'rbconfig';puts \"vendor/bundle/#{RUBY_ENGINE}/#{RbConfig::CONFIG['ruby_version']}\"")
|
|
out = run_no_pipe(command, user_env: true).strip
|
|
error "Problem detecting bundler vendor directory: #{out}" unless $?.success?
|
|
out
|
|
end
|
|
end
|
|
|
|
# the relative path to the bundler directory of gems
|
|
# @return [String] resulting path
|
|
def slug_vendor_base
|
|
instrument 'ruby.slug_vendor_base' do
|
|
@slug_vendor_base ||= self.class.slug_vendor_base
|
|
end
|
|
end
|
|
|
|
# the relative path to the vendored ruby directory
|
|
# @return [String] resulting path
|
|
def slug_vendor_ruby
|
|
"vendor/#{ruby_version.version_without_patchlevel}"
|
|
end
|
|
|
|
# the absolute path of the build ruby to use during the buildpack
|
|
# @return [String] resulting path
|
|
def build_ruby_path
|
|
"/tmp/#{ruby_version.version_without_patchlevel}"
|
|
end
|
|
|
|
# fetch the ruby version from bundler
|
|
# @return [String, nil] returns the ruby version if detected or nil if none is detected
|
|
def ruby_version
|
|
instrument 'ruby.ruby_version' do
|
|
return @ruby_version if @ruby_version
|
|
new_app = !File.exist?("vendor/heroku")
|
|
last_version_file = "buildpack_ruby_version"
|
|
last_version = nil
|
|
last_version = @metadata.read(last_version_file).strip if @metadata.exists?(last_version_file)
|
|
|
|
@ruby_version = LanguagePack::RubyVersion.new(bundler.ruby_version,
|
|
is_new: new_app,
|
|
last_version: last_version)
|
|
return @ruby_version
|
|
end
|
|
end
|
|
|
|
def set_default_web_concurrency
|
|
<<-EOF
|
|
case $(ulimit -u) in
|
|
256)
|
|
export HEROKU_RAM_LIMIT_MB=${HEROKU_RAM_LIMIT_MB:-512}
|
|
export WEB_CONCURRENCY=${WEB_CONCURRENCY:-2}
|
|
;;
|
|
512)
|
|
export HEROKU_RAM_LIMIT_MB=${HEROKU_RAM_LIMIT_MB:-1024}
|
|
export WEB_CONCURRENCY=${WEB_CONCURRENCY:-4}
|
|
;;
|
|
16384)
|
|
export HEROKU_RAM_LIMIT_MB=${HEROKU_RAM_LIMIT_MB:-2560}
|
|
export WEB_CONCURRENCY=${WEB_CONCURRENCY:-8}
|
|
;;
|
|
32768)
|
|
export HEROKU_RAM_LIMIT_MB=${HEROKU_RAM_LIMIT_MB:-6144}
|
|
export WEB_CONCURRENCY=${WEB_CONCURRENCY:-16}
|
|
;;
|
|
*)
|
|
;;
|
|
esac
|
|
EOF
|
|
end
|
|
|
|
# default JRUBY_OPTS
|
|
# return [String] string of JRUBY_OPTS
|
|
def default_jruby_opts
|
|
"-Xcompile.invokedynamic=false"
|
|
end
|
|
|
|
# sets up the environment variables for the build process
|
|
def setup_language_pack_environment(ruby_layer_path:, gem_layer_path:, bundle_path:, bundle_default_without:)
|
|
instrument 'ruby.setup_language_pack_environment' do
|
|
if ruby_version.jruby?
|
|
ENV["PATH"] += ":bin"
|
|
ENV["JRUBY_OPTS"] = env('JRUBY_BUILD_OPTS') || env('JRUBY_OPTS')
|
|
end
|
|
setup_ruby_install_env(ruby_layer_path)
|
|
|
|
# By default Node can address 1.5GB of memory, a limitation it inherits from
|
|
# the underlying v8 engine. This can occasionally cause issues during frontend
|
|
# builds where memory use can exceed this threshold.
|
|
#
|
|
# This passes an argument to all Node processes during the build, so that they
|
|
# can take advantage of all available memory on the build dynos.
|
|
ENV["NODE_OPTIONS"] ||= "--max_old_space_size=2560"
|
|
|
|
# TODO when buildpack-env-args rolls out, we can get rid of
|
|
# ||= and the manual setting below
|
|
default_config_vars.each do |key, value|
|
|
ENV[key] ||= value
|
|
end
|
|
|
|
paths = []
|
|
gem_path = "#{gem_layer_path}/#{slug_vendor_base}"
|
|
ENV["GEM_PATH"] = gem_path
|
|
ENV["GEM_HOME"] = gem_path
|
|
|
|
ENV["DISABLE_SPRING"] = "1"
|
|
|
|
# Rails has a binstub for yarn that doesn't work for all applications
|
|
# we need to ensure that yarn comes before local bin dir for that case
|
|
paths << yarn_preinstall_bin_path if yarn_preinstalled?
|
|
|
|
# Need to remove `./bin` folder since it links to the wrong --prefix ruby binstubs breaking require in Ruby 1.9.2 and 1.8.7.
|
|
# Because for 1.9.2 and 1.8.7 there is a "build" ruby and a non-"build" Ruby
|
|
paths << "#{File.expand_path(".")}/bin" unless ruby_version.ruby_192_or_lower?
|
|
|
|
paths << "#{gem_layer_path}/#{bundler_binstubs_path}" # Binstubs from bundler, eg. vendor/bundle/bin
|
|
paths << "#{gem_layer_path}/#{slug_vendor_base}/bin" # Binstubs from rubygems, eg. vendor/bundle/ruby/2.6.0/bin
|
|
paths << ENV["PATH"]
|
|
|
|
ENV["PATH"] = paths.join(":")
|
|
|
|
ENV["BUNDLE_WITHOUT"] = env("BUNDLE_WITHOUT") || bundle_default_without
|
|
if ENV["BUNDLE_WITHOUT"].include?(' ')
|
|
ENV["BUNDLE_WITHOUT"] = ENV["BUNDLE_WITHOUT"].tr(' ', ':')
|
|
|
|
warn("Your BUNDLE_WITHOUT contains a space, we are converting it to a colon `:` BUNDLE_WITHOUT=#{ENV["BUNDLE_WITHOUT"]}", inline: true)
|
|
end
|
|
ENV["BUNDLE_PATH"] = bundle_path
|
|
ENV["BUNDLE_BIN"] = bundler_binstubs_path
|
|
ENV["BUNDLE_DEPLOYMENT"] = "1"
|
|
ENV["BUNDLE_GLOBAL_PATH_APPENDS_RUBY_SCOPE"] = "1" if bundler.needs_ruby_global_append_path?
|
|
end
|
|
end
|
|
|
|
# Sets up the environment variables for subsequent processes run by
|
|
# muiltibuildpack. We can't use profile.d because $HOME isn't set up
|
|
def setup_export(layer = nil)
|
|
instrument 'ruby.setup_export' do
|
|
if layer
|
|
paths = ENV["PATH"]
|
|
else
|
|
paths = ENV["PATH"].split(":").map do |path|
|
|
/^\/.*/ !~ path ? "#{build_path}/#{path}" : path
|
|
end.join(":")
|
|
end
|
|
|
|
# TODO ensure path exported is correct
|
|
set_export_path "PATH", paths, layer
|
|
|
|
if layer
|
|
gem_path = "#{layer.path}/#{slug_vendor_base}"
|
|
else
|
|
gem_path = "#{build_path}/#{slug_vendor_base}"
|
|
end
|
|
set_export_path "GEM_PATH", gem_path, layer
|
|
set_export_default "LANG", "en_US.UTF-8", layer
|
|
|
|
# TODO handle jruby
|
|
if ruby_version.jruby?
|
|
set_export_default "JRUBY_OPTS", default_jruby_opts
|
|
end
|
|
|
|
set_export_default "BUNDLE_PATH", ENV["BUNDLE_PATH"], layer
|
|
set_export_default "BUNDLE_WITHOUT", ENV["BUNDLE_WITHOUT"], layer
|
|
set_export_default "BUNDLE_BIN", ENV["BUNDLE_BIN"], layer
|
|
set_export_default "BUNDLE_GLOBAL_PATH_APPENDS_RUBY_SCOPE", ENV["BUNDLE_GLOBAL_PATH_APPENDS_RUBY_SCOPE"], layer if bundler.needs_ruby_global_append_path?
|
|
set_export_default "BUNDLE_DEPLOYMENT", ENV["BUNDLE_DEPLOYMENT"], layer if ENV["BUNDLE_DEPLOYMENT"] # Unset on windows since we delete the Gemfile.lock
|
|
end
|
|
end
|
|
|
|
# sets up the profile.d script for this buildpack
|
|
def setup_profiled(ruby_layer_path: , gem_layer_path: )
|
|
instrument 'setup_profiled' do
|
|
profiled_path = []
|
|
|
|
# Rails has a binstub for yarn that doesn't work for all applications
|
|
# we need to ensure that yarn comes before local bin dir for that case
|
|
if yarn_preinstalled?
|
|
profiled_path << yarn_preinstall_bin_path.gsub(File.expand_path("."), "$HOME")
|
|
elsif has_yarn_binary?
|
|
profiled_path << "#{ruby_layer_path}/vendor/#{@yarn_installer.binary_path}"
|
|
end
|
|
profiled_path << "$HOME/bin" # /app in production
|
|
profiled_path << "#{gem_layer_path}/#{bundler_binstubs_path}" # Binstubs from bundler, eg. vendor/bundle/bin
|
|
profiled_path << "#{gem_layer_path}/#{slug_vendor_base}/bin" # Binstubs from rubygems, eg. vendor/bundle/ruby/2.6.0/bin
|
|
profiled_path << "$PATH"
|
|
|
|
set_env_default "LANG", "en_US.UTF-8"
|
|
set_env_override "GEM_PATH", "#{gem_layer_path}/#{slug_vendor_base}:$GEM_PATH"
|
|
set_env_override "PATH", profiled_path.join(":")
|
|
set_env_override "DISABLE_SPRING", "1"
|
|
|
|
set_env_default "MALLOC_ARENA_MAX", "2" if default_malloc_arena_max?
|
|
|
|
web_concurrency = env("SENSIBLE_DEFAULTS") ? set_default_web_concurrency : ""
|
|
add_to_profiled(web_concurrency, filename: "WEB_CONCURRENCY.sh", mode: "w") # always write that file, even if its empty (meaning no defaults apply), for interop with other buildpacks - and we overwrite the file rather than appending (which is the default)
|
|
|
|
# TODO handle JRUBY
|
|
if ruby_version.jruby?
|
|
set_env_default "JRUBY_OPTS", default_jruby_opts
|
|
end
|
|
|
|
set_env_default "BUNDLE_PATH", ENV["BUNDLE_PATH"]
|
|
set_env_default "BUNDLE_WITHOUT", ENV["BUNDLE_WITHOUT"]
|
|
set_env_default "BUNDLE_BIN", ENV["BUNDLE_BIN"]
|
|
set_env_default "BUNDLE_GLOBAL_PATH_APPENDS_RUBY_SCOPE", ENV["BUNDLE_GLOBAL_PATH_APPENDS_RUBY_SCOPE"] if bundler.needs_ruby_global_append_path?
|
|
set_env_default "BUNDLE_DEPLOYMENT", ENV["BUNDLE_DEPLOYMENT"] if ENV["BUNDLE_DEPLOYMENT"] # Unset on windows since we delete the Gemfile.lock
|
|
end
|
|
end
|
|
|
|
def warn_outdated_ruby
|
|
return unless defined?(@outdated_version_check)
|
|
|
|
@warn_outdated ||= begin
|
|
@outdated_version_check.join
|
|
|
|
warn_outdated_minor
|
|
warn_outdated_eol
|
|
warn_stack_upgrade
|
|
true
|
|
end
|
|
end
|
|
|
|
def warn_stack_upgrade
|
|
return unless defined?(@ruby_download_check)
|
|
return unless @ruby_download_check.next_stack(current_stack: stack)
|
|
return if @ruby_download_check.exists_on_next_stack?(current_stack: stack)
|
|
|
|
warn(<<~WARNING)
|
|
Your Ruby version is not present on the next stack
|
|
|
|
You are currently using #{ruby_version.version_for_download} on #{stack} stack.
|
|
This version does not exist on #{@ruby_download_check.next_stack(current_stack: stack)}. In order to upgrade your stack you will
|
|
need to upgrade to a supported Ruby version.
|
|
|
|
For a list of supported Ruby versions see:
|
|
https://devcenter.heroku.com/articles/ruby-support#supported-runtimes
|
|
|
|
For a list of the oldest Ruby versions present on a given stack see:
|
|
https://devcenter.heroku.com/articles/ruby-support#oldest-available-runtimes
|
|
WARNING
|
|
end
|
|
|
|
def warn_outdated_eol
|
|
return unless @outdated_version_check.maybe_eol?
|
|
|
|
if @outdated_version_check.eol?
|
|
warn(<<~WARNING)
|
|
EOL Ruby Version
|
|
|
|
You are using a Ruby version that has reached its End of Life (EOL)
|
|
|
|
We strongly suggest you upgrade to Ruby #{@outdated_version_check.suggest_ruby_eol_version} or later
|
|
|
|
Your current Ruby version no longer receives security updates from
|
|
Ruby Core and may have serious vulnerabilities. While you will continue
|
|
to be able to deploy on Heroku with this Ruby version you must upgrade
|
|
to a non-EOL version to be eligible to receive support.
|
|
|
|
Upgrade your Ruby version as soon as possible.
|
|
|
|
For a list of supported Ruby versions see:
|
|
https://devcenter.heroku.com/articles/ruby-support#supported-runtimes
|
|
WARNING
|
|
else
|
|
# Maybe EOL
|
|
warn(<<~WARNING)
|
|
Potential EOL Ruby Version
|
|
|
|
You are using a Ruby version that has either reached its End of Life (EOL)
|
|
or will reach its End of Life on December 25th of this year.
|
|
|
|
We suggest you upgrade to Ruby #{@outdated_version_check.suggest_ruby_eol_version} or later
|
|
|
|
Once a Ruby version becomes EOL, it will no longer receive
|
|
security updates from Ruby core and may have serious vulnerabilities.
|
|
|
|
Please upgrade your Ruby version.
|
|
|
|
For a list of supported Ruby versions see:
|
|
https://devcenter.heroku.com/articles/ruby-support#supported-runtimes
|
|
WARNING
|
|
end
|
|
end
|
|
|
|
def warn_outdated_minor
|
|
return if @outdated_version_check.latest_minor_version?
|
|
|
|
warn(<<~WARNING)
|
|
There is a more recent Ruby version available for you to use:
|
|
|
|
#{@outdated_version_check.suggested_ruby_minor_version}
|
|
|
|
The latest version will include security and bug fixes. We always recommend
|
|
running the latest version of your minor release.
|
|
|
|
Please upgrade your Ruby version.
|
|
|
|
For all available Ruby versions see:
|
|
https://devcenter.heroku.com/articles/ruby-support#supported-runtimes
|
|
WARNING
|
|
end
|
|
|
|
# install the vendored ruby
|
|
# @return [Boolean] true if it installs the vendored ruby and false otherwise
|
|
def install_ruby(install_path, build_ruby_path = nil)
|
|
instrument 'ruby.install_ruby' do
|
|
# Could do a compare operation to avoid re-downloading ruby
|
|
return false unless ruby_version
|
|
installer = LanguagePack::Installers::RubyInstaller.installer(ruby_version).new(@stack)
|
|
|
|
@ruby_download_check = LanguagePack::Helpers::DownloadPresence.new(ruby_version.file_name)
|
|
@ruby_download_check.call
|
|
|
|
if ruby_version.build?
|
|
installer.fetch_unpack(ruby_version, build_ruby_path, true)
|
|
end
|
|
|
|
installer.install(ruby_version, install_path)
|
|
|
|
@outdated_version_check = LanguagePack::Helpers::OutdatedRubyVersion.new(
|
|
current_ruby_version: ruby_version,
|
|
fetcher: installer.fetcher
|
|
)
|
|
@outdated_version_check.call
|
|
|
|
@metadata.write("buildpack_ruby_version", ruby_version.version_for_download)
|
|
|
|
topic "Using Ruby version: #{ruby_version.version_for_download}"
|
|
if !ruby_version.set
|
|
warn(<<~WARNING)
|
|
You have not declared a Ruby version in your Gemfile.
|
|
|
|
To declare a Ruby version add this line to your Gemfile:
|
|
|
|
```
|
|
ruby "#{LanguagePack::RubyVersion::DEFAULT_VERSION_NUMBER}"
|
|
```
|
|
|
|
For more information see:
|
|
https://devcenter.heroku.com/articles/ruby-versions
|
|
WARNING
|
|
end
|
|
|
|
if ruby_version.warn_ruby_26_bundler?
|
|
warn(<<~WARNING, inline: true)
|
|
There is a known bundler bug with your version of Ruby
|
|
|
|
Your version of Ruby contains a problem with the built-in integration of bundler. If
|
|
you encounter a bundler error you need to upgrade your Ruby version. We suggest you upgrade to:
|
|
|
|
#{@outdated_version_check.suggested_ruby_minor_version}
|
|
|
|
For more information see:
|
|
https://devcenter.heroku.com/articles/bundler-version#known-upgrade-issues
|
|
WARNING
|
|
end
|
|
end
|
|
|
|
true
|
|
rescue LanguagePack::Fetcher::FetchError
|
|
if @ruby_download_check.does_not_exist?
|
|
message = <<~ERROR
|
|
The Ruby version you are trying to install does not exist: #{ruby_version.version_for_download}
|
|
ERROR
|
|
else
|
|
message = <<~ERROR
|
|
The Ruby version you are trying to install does not exist on this stack.
|
|
|
|
You are trying to install #{ruby_version.version_for_download} on #{stack}.
|
|
|
|
Ruby #{ruby_version.version_for_download} is present on the following stacks:
|
|
|
|
- #{@ruby_download_check.valid_stack_list.join("\n - ")}
|
|
ERROR
|
|
|
|
if env("CI")
|
|
message << <<~ERROR
|
|
|
|
On Heroku CI you can set your stack in the `app.json`. For example:
|
|
|
|
```
|
|
"stack": "heroku-20"
|
|
```
|
|
ERROR
|
|
end
|
|
end
|
|
|
|
message << <<~ERROR
|
|
|
|
Heroku recommends you use the latest supported Ruby version listed here:
|
|
https://devcenter.heroku.com/articles/ruby-support#supported-runtimes
|
|
|
|
For more information on syntax for declaring a Ruby version see:
|
|
https://devcenter.heroku.com/articles/ruby-versions
|
|
ERROR
|
|
|
|
error message
|
|
end
|
|
|
|
# TODO make this compatible with CNB
|
|
def new_app?
|
|
@new_app ||= !File.exist?("vendor/heroku")
|
|
end
|
|
|
|
# find the ruby install path for its binstubs during build
|
|
# @return [String] resulting path or empty string if ruby is not vendored
|
|
def ruby_install_binstub_path(ruby_layer_path = ".")
|
|
@ruby_install_binstub_path ||=
|
|
if ruby_version.build?
|
|
"#{build_ruby_path}/bin"
|
|
elsif ruby_version
|
|
"#{ruby_layer_path}/#{slug_vendor_ruby}/bin"
|
|
else
|
|
""
|
|
end
|
|
end
|
|
|
|
# setup the environment so we can use the vendored ruby
|
|
def setup_ruby_install_env(ruby_layer_path = ".")
|
|
instrument 'ruby.setup_ruby_install_env' do
|
|
ENV["PATH"] = "#{File.expand_path(ruby_install_binstub_path(ruby_layer_path))}:#{ENV["PATH"]}"
|
|
end
|
|
end
|
|
|
|
# installs vendored gems into the slug
|
|
def install_bundler_in_app(bundler_dir)
|
|
instrument 'ruby.install_language_pack_gems' do
|
|
FileUtils.mkdir_p(bundler_dir)
|
|
Dir.chdir(bundler_dir) do |dir|
|
|
`cp -R #{bundler.bundler_path}/. .`
|
|
end
|
|
|
|
# write bundler shim, so we can control the version bundler used
|
|
# Ruby 2.6.0 started vendoring bundler
|
|
write_bundler_shim("vendor/bundle/bin") if ruby_version.vendored_bundler?
|
|
end
|
|
end
|
|
|
|
# default set of binaries to install
|
|
# @return [Array] resulting list
|
|
def binaries
|
|
add_node_js_binary + add_yarn_binary
|
|
end
|
|
|
|
# vendors binaries into the slug
|
|
def install_binaries
|
|
instrument 'ruby.install_binaries' do
|
|
binaries.each {|binary| install_binary(binary) }
|
|
Dir["bin/*"].each {|path| run("chmod +x #{path}") }
|
|
end
|
|
end
|
|
|
|
# vendors individual binary into the slug
|
|
# @param [String] name of the binary package from S3.
|
|
# Example: https://s3.amazonaws.com/language-pack-ruby/node-0.4.7.tgz, where name is "node-0.4.7"
|
|
def install_binary(name)
|
|
topic "Installing #{name}"
|
|
bin_dir = "bin"
|
|
FileUtils.mkdir_p bin_dir
|
|
Dir.chdir(bin_dir) do |dir|
|
|
if name.match(/^node\-/)
|
|
@node_installer.install
|
|
# need to set PATH here b/c `node-gyp` can change the CWD, but still depends on executing node.
|
|
# the current PATH is relative, but it needs to be absolute for this.
|
|
# doing this here also prevents it from being exported during runtime
|
|
node_bin_path = File.absolute_path(".")
|
|
# this needs to be set after so other binaries in bin/ don't take precedence"
|
|
ENV["PATH"] = "#{ENV["PATH"]}:#{node_bin_path}"
|
|
elsif name.match(/^yarn\-/)
|
|
FileUtils.mkdir_p("../vendor")
|
|
Dir.chdir("../vendor") do |vendor_dir|
|
|
@yarn_installer.install
|
|
yarn_path = File.absolute_path("#{vendor_dir}/#{@yarn_installer.binary_path}")
|
|
ENV["PATH"] = "#{yarn_path}:#{ENV["PATH"]}"
|
|
end
|
|
else
|
|
@fetchers[:buildpack].fetch_untar("#{name}.tgz")
|
|
end
|
|
end
|
|
end
|
|
|
|
# removes a binary from the slug
|
|
# @param [String] relative path of the binary on the slug
|
|
def uninstall_binary(path)
|
|
FileUtils.rm File.join('bin', File.basename(path)), :force => true
|
|
end
|
|
|
|
def load_default_cache?
|
|
new_app? && ruby_version.default?
|
|
end
|
|
|
|
# loads a default bundler cache for new apps to speed up initial bundle installs
|
|
def load_default_cache
|
|
instrument "ruby.load_default_cache" do
|
|
if false # load_default_cache?
|
|
puts "New app detected loading default bundler cache"
|
|
patchlevel = run("ruby -e 'puts RUBY_PATCHLEVEL'").strip
|
|
cache_name = "#{LanguagePack::RubyVersion::DEFAULT_VERSION}-p#{patchlevel}-default-cache"
|
|
@fetchers[:buildpack].fetch_untar("#{cache_name}.tgz")
|
|
end
|
|
end
|
|
end
|
|
|
|
# remove `vendor/bundle` that comes from the git repo
|
|
# in case there are native ext.
|
|
# users should be using `bundle pack` instead.
|
|
# https://github.com/heroku/heroku-buildpack-ruby/issues/21
|
|
def remove_vendor_bundle
|
|
if File.exists?("vendor/bundle")
|
|
warn(<<-WARNING)
|
|
Removing `vendor/bundle`.
|
|
Checking in `vendor/bundle` is not supported. Please remove this directory
|
|
and add it to your .gitignore. To vendor your gems with Bundler, use
|
|
`bundle pack` instead.
|
|
WARNING
|
|
FileUtils.rm_rf("vendor/bundle")
|
|
end
|
|
end
|
|
|
|
def bundler_binstubs_path
|
|
"vendor/bundle/bin"
|
|
end
|
|
|
|
def bundler_path
|
|
@bundler_path ||= "#{slug_vendor_base}/gems/#{bundler.dir_name}"
|
|
end
|
|
|
|
def write_bundler_shim(path)
|
|
FileUtils.mkdir_p(path)
|
|
shim_path = "#{path}/bundle"
|
|
File.open(shim_path, "w") do |file|
|
|
file.print <<-BUNDLE
|
|
#!/usr/bin/env ruby
|
|
require 'rubygems'
|
|
|
|
version = "#{bundler.version}"
|
|
|
|
if ARGV.first
|
|
str = ARGV.first
|
|
str = str.dup.force_encoding("BINARY") if str.respond_to? :force_encoding
|
|
if str =~ /\A_(.*)_\z/ and Gem::Version.correct?($1) then
|
|
version = $1
|
|
ARGV.shift
|
|
end
|
|
end
|
|
|
|
if Gem.respond_to?(:activate_bin_path)
|
|
load Gem.activate_bin_path('bundler', 'bundle', version)
|
|
else
|
|
gem "bundler", version
|
|
load Gem.bin_path("bundler", "bundle", version)
|
|
end
|
|
BUNDLE
|
|
end
|
|
FileUtils.chmod(0755, shim_path)
|
|
end
|
|
|
|
# runs bundler to install the dependencies
|
|
def build_bundler
|
|
instrument 'ruby.build_bundler' do
|
|
log("bundle") do
|
|
if File.exist?("#{Dir.pwd}/.bundle/config")
|
|
warn(<<~WARNING, inline: true)
|
|
You have the `.bundle/config` file checked into your repository
|
|
It contains local state like the location of the installed bundle
|
|
as well as configured git local gems, and other settings that should
|
|
not be shared between multiple checkouts of a single repo. Please
|
|
remove the `.bundle/` folder from your repo and add it to your `.gitignore` file.
|
|
|
|
https://devcenter.heroku.com/articles/bundler-configuration
|
|
WARNING
|
|
end
|
|
|
|
if bundler.windows_gemfile_lock?
|
|
log("bundle", "has_windows_gemfile_lock")
|
|
|
|
File.unlink("Gemfile.lock")
|
|
ENV.delete("BUNDLE_DEPLOYMENT")
|
|
|
|
warn(<<~WARNING, inline: true)
|
|
Removing `Gemfile.lock` because it was generated on Windows.
|
|
Bundler will do a full resolve so native gems are handled properly.
|
|
This may result in unexpected gem versions being used in your app.
|
|
In rare occasions Bundler may not be able to resolve your dependencies at all.
|
|
|
|
https://devcenter.heroku.com/articles/bundler-windows-gemfile
|
|
WARNING
|
|
end
|
|
|
|
bundle_command = String.new("")
|
|
bundle_command << "BUNDLE_WITHOUT='#{ENV["BUNDLE_WITHOUT"]}' "
|
|
bundle_command << "BUNDLE_PATH=#{ENV["BUNDLE_PATH"]} "
|
|
bundle_command << "BUNDLE_BIN=#{ENV["BUNDLE_BIN"]} "
|
|
bundle_command << "BUNDLE_DEPLOYMENT=#{ENV["BUNDLE_DEPLOYMENT"]} " if ENV["BUNDLE_DEPLOYMENT"] # Unset on windows since we delete the Gemfile.lock
|
|
bundle_command << "BUNDLE_GLOBAL_PATH_APPENDS_RUBY_SCOPE=#{ENV["BUNDLE_GLOBAL_PATH_APPENDS_RUBY_SCOPE"]} " if bundler.needs_ruby_global_append_path?
|
|
bundle_command << "bundle install -j4"
|
|
|
|
topic("Installing dependencies using bundler #{bundler.version}")
|
|
|
|
bundler_output = String.new("")
|
|
bundle_time = nil
|
|
env_vars = {}
|
|
Dir.mktmpdir("libyaml-") do |tmpdir|
|
|
libyaml_dir = "#{tmpdir}/#{LIBYAML_PATH}"
|
|
|
|
# need to setup compile environment for the psych gem
|
|
yaml_include = File.expand_path("#{libyaml_dir}/include").shellescape
|
|
yaml_lib = File.expand_path("#{libyaml_dir}/lib").shellescape
|
|
pwd = Dir.pwd
|
|
bundler_path = "#{pwd}/#{slug_vendor_base}/gems/#{bundler.dir_name}/lib"
|
|
|
|
# we need to set BUNDLE_CONFIG and BUNDLE_GEMFILE for
|
|
# codon since it uses bundler.
|
|
env_vars["BUNDLE_GEMFILE"] = "#{pwd}/Gemfile"
|
|
env_vars["BUNDLE_CONFIG"] = "#{pwd}/.bundle/config"
|
|
env_vars["CPATH"] = noshellescape("#{yaml_include}:$CPATH")
|
|
env_vars["CPPATH"] = noshellescape("#{yaml_include}:$CPPATH")
|
|
env_vars["LIBRARY_PATH"] = noshellescape("#{yaml_lib}:$LIBRARY_PATH")
|
|
env_vars["RUBYOPT"] = syck_hack
|
|
env_vars["NOKOGIRI_USE_SYSTEM_LIBRARIES"] = "true"
|
|
env_vars["BUNDLE_DISABLE_VERSION_CHECK"] = "true"
|
|
env_vars["BUNDLER_LIB_PATH"] = "#{bundler_path}" if ruby_version.ruby_version == "1.8.7"
|
|
env_vars["BUNDLE_DISABLE_VERSION_CHECK"] = "true"
|
|
|
|
puts "Running: #{bundle_command}"
|
|
instrument "ruby.bundle_install" do
|
|
bundle_time = Benchmark.realtime do
|
|
bundler_output << pipe("#{bundle_command} --no-clean", out: "2>&1", env: env_vars, user_env: true)
|
|
end
|
|
end
|
|
end
|
|
|
|
if $?.success?
|
|
puts "Bundle completed (#{"%.2f" % bundle_time}s)"
|
|
log "bundle", :status => "success"
|
|
puts "Cleaning up the bundler cache."
|
|
instrument "ruby.bundle_clean" do
|
|
# Only show bundle clean output when not using default cache
|
|
if load_default_cache?
|
|
run("bundle clean > /dev/null", user_env: true, env: env_vars)
|
|
else
|
|
pipe("bundle clean", out: "2> /dev/null", user_env: true, env: env_vars)
|
|
end
|
|
end
|
|
@bundler_cache.store
|
|
|
|
# Keep gem cache out of the slug
|
|
FileUtils.rm_rf("#{slug_vendor_base}/cache")
|
|
else
|
|
mcount "fail.bundle.install"
|
|
log "bundle", :status => "failure"
|
|
error_message = "Failed to install gems via Bundler."
|
|
puts "Bundler Output: #{bundler_output}"
|
|
if bundler_output.match(/An error occurred while installing sqlite3/)
|
|
mcount "fail.sqlite3"
|
|
error_message += <<~ERROR
|
|
|
|
Detected sqlite3 gem which is not supported on Heroku:
|
|
https://devcenter.heroku.com/articles/sqlite3
|
|
ERROR
|
|
end
|
|
|
|
if bundler_output.match(/but your Gemfile specified/)
|
|
mcount "fail.ruby_version_mismatch"
|
|
error_message += <<~ERROR
|
|
|
|
Detected a mismatch between your Ruby version installed and
|
|
Ruby version specified in Gemfile or Gemfile.lock. You can
|
|
correct this by running:
|
|
|
|
$ bundle update --ruby
|
|
$ git add Gemfile.lock
|
|
$ git commit -m "update ruby version"
|
|
|
|
If this does not solve the issue please see this documentation:
|
|
|
|
https://devcenter.heroku.com/articles/ruby-versions#your-ruby-version-is-x-but-your-gemfile-specified-y
|
|
ERROR
|
|
end
|
|
|
|
error error_message
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def post_bundler
|
|
instrument "ruby.post_bundler" do
|
|
Dir[File.join(slug_vendor_base, "**", ".git")].each do |dir|
|
|
FileUtils.rm_rf(dir)
|
|
end
|
|
bundler.clean
|
|
end
|
|
end
|
|
|
|
# RUBYOPT line that requires syck_hack file
|
|
# @return [String] require string if needed or else an empty string
|
|
def syck_hack
|
|
instrument "ruby.syck_hack" do
|
|
syck_hack_file = File.expand_path(File.join(File.dirname(__FILE__), "../../vendor/syck_hack"))
|
|
rv = run_stdout('ruby -e "puts RUBY_VERSION"').strip
|
|
# < 1.9.3 includes syck, so we need to use the syck hack
|
|
if Gem::Version.new(rv) < Gem::Version.new("1.9.3")
|
|
"-r#{syck_hack_file}"
|
|
else
|
|
""
|
|
end
|
|
end
|
|
end
|
|
|
|
# writes ERB based database.yml for Rails. The database.yml uses the DATABASE_URL from the environment during runtime.
|
|
def create_database_yml
|
|
instrument 'ruby.create_database_yml' do
|
|
return false unless File.directory?("config")
|
|
return false if bundler.has_gem?('activerecord') && bundler.gem_version('activerecord') >= Gem::Version.new('4.1.0.beta1')
|
|
|
|
log("create_database_yml") do
|
|
topic("Writing config/database.yml to read from DATABASE_URL")
|
|
File.open("config/database.yml", "w") do |file|
|
|
file.puts <<-DATABASE_YML
|
|
<%
|
|
|
|
require 'cgi'
|
|
require 'uri'
|
|
|
|
begin
|
|
uri = URI.parse(ENV["DATABASE_URL"])
|
|
rescue URI::InvalidURIError
|
|
raise "Invalid DATABASE_URL"
|
|
end
|
|
|
|
raise "No RACK_ENV or RAILS_ENV found" unless ENV["RAILS_ENV"] || ENV["RACK_ENV"]
|
|
|
|
def attribute(name, value, force_string = false)
|
|
if value
|
|
value_string =
|
|
if force_string
|
|
'"' + value + '"'
|
|
else
|
|
value
|
|
end
|
|
"\#{name}: \#{value_string}"
|
|
else
|
|
""
|
|
end
|
|
end
|
|
|
|
adapter = uri.scheme
|
|
adapter = "postgresql" if adapter == "postgres"
|
|
|
|
database = (uri.path || "").split("/")[1]
|
|
|
|
username = uri.user
|
|
password = uri.password
|
|
|
|
host = uri.host
|
|
port = uri.port
|
|
|
|
params = CGI.parse(uri.query || "")
|
|
|
|
%>
|
|
|
|
<%= ENV["RAILS_ENV"] || ENV["RACK_ENV"] %>:
|
|
<%= attribute "adapter", adapter %>
|
|
<%= attribute "database", database %>
|
|
<%= attribute "username", username %>
|
|
<%= attribute "password", password, true %>
|
|
<%= attribute "host", host %>
|
|
<%= attribute "port", port %>
|
|
|
|
<% params.each do |key, value| %>
|
|
<%= key %>: <%= value.first %>
|
|
<% end %>
|
|
DATABASE_YML
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def rake
|
|
@rake ||= begin
|
|
rake_gem_available = bundler.has_gem?("rake") || ruby_version.rake_is_vendored?
|
|
raise_on_fail = bundler.gem_version('railties') && bundler.gem_version('railties') > Gem::Version.new('3.x')
|
|
|
|
topic "Detecting rake tasks"
|
|
rake = LanguagePack::Helpers::RakeRunner.new(rake_gem_available)
|
|
rake.load_rake_tasks!({ env: rake_env }, raise_on_fail)
|
|
rake
|
|
end
|
|
end
|
|
|
|
def rake_env
|
|
if database_url
|
|
{ "DATABASE_URL" => database_url }
|
|
else
|
|
{}
|
|
end.merge(user_env_hash)
|
|
end
|
|
|
|
def database_url
|
|
env("DATABASE_URL") if env("DATABASE_URL")
|
|
end
|
|
|
|
# executes the block with GIT_DIR environment variable removed since it can mess with the current working directory git thinks it's in
|
|
# @param [block] block to be executed in the GIT_DIR free context
|
|
def allow_git(&blk)
|
|
git_dir = ENV.delete("GIT_DIR") # can mess with bundler
|
|
blk.call
|
|
ENV["GIT_DIR"] = git_dir
|
|
end
|
|
|
|
# decides if we need to enable the dev database addon
|
|
# @return [Array] the database addon if the pg gem is detected or an empty Array if it isn't.
|
|
def add_dev_database_addon
|
|
pg_adapters.any? {|a| bundler.has_gem?(a) } ? ['heroku-postgresql'] : []
|
|
end
|
|
|
|
def pg_adapters
|
|
[
|
|
"pg",
|
|
"activerecord-jdbcpostgresql-adapter",
|
|
"jdbc-postgres",
|
|
"jdbc-postgresql",
|
|
"jruby-pg",
|
|
"rjack-jdbc-postgres",
|
|
"tgbyte-activerecord-jdbcpostgresql-adapter"
|
|
]
|
|
end
|
|
|
|
# decides if we need to install the node.js binary
|
|
# @note execjs will blow up if no JS RUNTIME is detected and is loaded.
|
|
# @return [Array] the node.js binary path if we need it or an empty Array
|
|
def add_node_js_binary
|
|
return [] if node_js_preinstalled?
|
|
|
|
if Pathname(build_path).join("package.json").exist? ||
|
|
bundler.has_gem?('execjs') ||
|
|
bundler.has_gem?('webpacker')
|
|
[@node_installer.binary_path]
|
|
else
|
|
[]
|
|
end
|
|
end
|
|
|
|
def add_yarn_binary
|
|
return [] if yarn_preinstalled?
|
|
|
|
|
if Pathname(build_path).join("yarn.lock").exist? || bundler.has_gem?('webpacker')
|
|
[@yarn_installer.name]
|
|
else
|
|
[]
|
|
end
|
|
end
|
|
|
|
def has_yarn_binary?
|
|
add_yarn_binary.any?
|
|
end
|
|
|
|
# checks if node.js is installed via the official heroku-buildpack-nodejs using multibuildpack
|
|
# @return String if it's detected and false if it isn't
|
|
def node_preinstall_bin_path
|
|
return @node_preinstall_bin_path if defined?(@node_preinstall_bin_path)
|
|
|
|
legacy_path = "#{Dir.pwd}/#{NODE_BP_PATH}"
|
|
path = run("which node").strip
|
|
if path && $?.success?
|
|
@node_preinstall_bin_path = path
|
|
elsif run("#{legacy_path}/node -v") && $?.success?
|
|
@node_preinstall_bin_path = legacy_path
|
|
else
|
|
@node_preinstall_bin_path = false
|
|
end
|
|
end
|
|
alias :node_js_preinstalled? :node_preinstall_bin_path
|
|
|
|
def node_not_preinstalled?
|
|
!node_js_preinstalled?
|
|
end
|
|
|
|
# Example: tmp/build_8523f77fb96a956101d00988dfeed9d4/.heroku/yarn/bin/ (without the `yarn` at the end)
|
|
def yarn_preinstall_bin_path
|
|
(yarn_preinstall_binary_path || "").chomp("/yarn")
|
|
end
|
|
|
|
# Example `tmp/build_8523f77fb96a956101d00988dfeed9d4/.heroku/yarn/bin/yarn`
|
|
def yarn_preinstall_binary_path
|
|
return @yarn_preinstall_binary_path if defined?(@yarn_preinstall_binary_path)
|
|
|
|
path = run("which yarn").strip
|
|
if path && $?.success?
|
|
@yarn_preinstall_binary_path = path
|
|
else
|
|
@yarn_preinstall_binary_path = false
|
|
end
|
|
end
|
|
|
|
def yarn_preinstalled?
|
|
yarn_preinstall_binary_path
|
|
end
|
|
|
|
def yarn_not_preinstalled?
|
|
!yarn_preinstalled?
|
|
end
|
|
|
|
def run_assets_precompile_rake_task
|
|
instrument 'ruby.run_assets_precompile_rake_task' do
|
|
|
|
precompile = rake.task("assets:precompile")
|
|
return true unless precompile.is_defined?
|
|
|
|
topic "Precompiling assets"
|
|
precompile.invoke(env: rake_env)
|
|
if precompile.success?
|
|
puts "Asset precompilation completed (#{"%.2f" % precompile.time}s)"
|
|
else
|
|
precompile_fail(precompile.output)
|
|
end
|
|
end
|
|
end
|
|
|
|
def precompile_fail(output)
|
|
mcount "fail.assets_precompile"
|
|
log "assets_precompile", :status => "failure"
|
|
msg = "Precompiling assets failed.\n"
|
|
if output.match(/(127\.0\.0\.1)|(org\.postgresql\.util)/)
|
|
msg << "Attempted to access a nonexistent database:\n"
|
|
msg << "https://devcenter.heroku.com/articles/pre-provision-database\n"
|
|
end
|
|
|
|
sprockets_version = bundler.gem_version('sprockets')
|
|
if output.match(/Sprockets::FileNotFound/) && (sprockets_version < Gem::Version.new('4.0.0.beta7') && sprockets_version > Gem::Version.new('4.0.0.beta4'))
|
|
mcount "fail.assets_precompile.file_not_found_beta"
|
|
msg << "If you have this file in your project\n"
|
|
msg << "try upgrading to Sprockets 4.0.0.beta7 or later:\n"
|
|
msg << "https://github.com/rails/sprockets/pull/547\n"
|
|
end
|
|
|
|
error msg
|
|
end
|
|
|
|
def bundler_cache
|
|
"vendor/bundle"
|
|
end
|
|
|
|
def valid_bundler_cache?(path, metadata)
|
|
full_ruby_version = run_stdout(%q(ruby -v)).strip
|
|
rubygems_version = run_stdout(%q(gem -v)).strip
|
|
old_rubygems_version = nil
|
|
|
|
old_rubygems_version = metadata[:ruby_version]
|
|
old_stack = metadata[:stack]
|
|
old_stack ||= DEFAULT_LEGACY_STACK
|
|
|
|
stack_change = old_stack != @stack
|
|
if !new_app? && stack_change
|
|
return [false, "Purging Cache. Changing stack from #{old_stack} to #{@stack}"]
|
|
end
|
|
|
|
# fix bug from v37 deploy
|
|
if File.exists?("#{path}/vendor/ruby_version")
|
|
puts "Broken cache detected. Purging build cache."
|
|
cache.clear("vendor")
|
|
FileUtils.rm_rf("#{path}/vendor/ruby_version")
|
|
return [false, "Broken cache detected. Purging build cache."]
|
|
# fix bug introduced in v38
|
|
elsif !metadata.include?(:buildpack_version) && metadata.include?(:ruby_version)
|
|
puts "Broken cache detected. Purging build cache."
|
|
return [false, "Broken cache detected. Purging build cache."]
|
|
elsif (@bundler_cache.exists? || @bundler_cache.old?) && full_ruby_version != metadata[:ruby_version]
|
|
return [false, <<-MESSAGE]
|
|
Ruby version change detected. Clearing bundler cache.
|
|
Old: #{metadata[:ruby_version]}
|
|
New: #{full_ruby_version}
|
|
MESSAGE
|
|
end
|
|
|
|
# fix git gemspec bug from Bundler 1.3.0+ upgrade
|
|
if File.exists?(bundler_cache) && !metadata.include?(:bundler_version) && !run("find #{path}/vendor/bundle/*/*/bundler/gems/*/ -name *.gemspec").include?("No such file or directory")
|
|
return [false, "Old bundler cache detected. Clearing bundler cache."]
|
|
end
|
|
|
|
# fix for https://github.com/heroku/heroku-buildpack-ruby/issues/86
|
|
if (!metadata.include?(:rubygems_version) ||
|
|
(old_rubygems_version == "2.0.0" && old_rubygems_version != rubygems_version)) &&
|
|
metadata.include?(:ruby_version) && metadata[:ruby_version].strip.include?("ruby 2.0.0p0")
|
|
return [false, "Updating to rubygems #{rubygems_version}. Clearing bundler cache."]
|
|
end
|
|
|
|
# fix for https://github.com/sparklemotion/nokogiri/issues/923
|
|
if metadata.include?(:buildpack_version) && (bv = metadata[:buildpack_version].sub('v', '').to_i) && bv != 0 && bv <= 76
|
|
return [false, <<-MESSAGE]
|
|
Fixing nokogiri install. Clearing bundler cache.
|
|
See https://github.com/sparklemotion/nokogiri/issues/923.
|
|
MESSAGE
|
|
end
|
|
|
|
# recompile nokogiri to use new libyaml
|
|
if metadata.include?(:buildpack_version) && (bv = metadata[:buildpack_version].sub('v', '').to_i) && bv != 0 && bv <= 99 && bundler.has_gem?("psych")
|
|
return [false, <<-MESSAGE]
|
|
Need to recompile psych for CVE-2013-6393. Clearing bundler cache.
|
|
See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=737076.
|
|
MESSAGE
|
|
end
|
|
|
|
# recompile gems for libyaml 0.1.7 update
|
|
if metadata.include?(:buildpack_version) && (bv = metadata[:buildpack_version].sub('v', '').to_i) && bv != 0 && bv <= 147 &&
|
|
(metadata.include?(:ruby_version) && metadata[:ruby_version].match(/ruby 2\.1\.(9|10)/) ||
|
|
bundler.has_gem?("psych")
|
|
)
|
|
return [false, <<-MESSAGE]
|
|
Need to recompile gems for CVE-2014-2014-9130. Clearing bundler cache.
|
|
See https://devcenter.heroku.com/changelog-items/1016.
|
|
MESSAGE
|
|
end
|
|
|
|
true
|
|
end
|
|
|
|
def load_bundler_cache
|
|
instrument "ruby.load_bundler_cache" do
|
|
cache.load "vendor"
|
|
|
|
full_ruby_version = run_stdout(%q(ruby -v)).strip
|
|
rubygems_version = run_stdout(%q(gem -v)).strip
|
|
heroku_metadata = "vendor/heroku"
|
|
old_rubygems_version = nil
|
|
ruby_version_cache = "ruby_version"
|
|
buildpack_version_cache = "buildpack_version"
|
|
bundler_version_cache = "bundler_version"
|
|
rubygems_version_cache = "rubygems_version"
|
|
stack_cache = "stack"
|
|
|
|
# bundle clean does not remove binstubs
|
|
FileUtils.rm_rf("vendor/bundler/bin")
|
|
|
|
old_rubygems_version = @metadata.read(ruby_version_cache).strip if @metadata.exists?(ruby_version_cache)
|
|
old_stack = @metadata.read(stack_cache).strip if @metadata.exists?(stack_cache)
|
|
old_stack ||= DEFAULT_LEGACY_STACK
|
|
|
|
stack_change = old_stack != @stack
|
|
convert_stack = @bundler_cache.old?
|
|
@bundler_cache.convert_stack(stack_change) if convert_stack
|
|
if !new_app? && stack_change
|
|
puts "Purging Cache. Changing stack from #{old_stack} to #{@stack}"
|
|
purge_bundler_cache(old_stack)
|
|
elsif !new_app? && !convert_stack
|
|
@bundler_cache.load
|
|
end
|
|
|
|
# fix bug from v37 deploy
|
|
if File.exists?("vendor/ruby_version")
|
|
puts "Broken cache detected. Purging build cache."
|
|
cache.clear("vendor")
|
|
FileUtils.rm_rf("vendor/ruby_version")
|
|
purge_bundler_cache
|
|
# fix bug introduced in v38
|
|
elsif !@metadata.include?(buildpack_version_cache) && @metadata.exists?(ruby_version_cache)
|
|
puts "Broken cache detected. Purging build cache."
|
|
purge_bundler_cache
|
|
elsif (@bundler_cache.exists? || @bundler_cache.old?) && @metadata.exists?(ruby_version_cache) && full_ruby_version != @metadata.read(ruby_version_cache).strip
|
|
puts "Ruby version change detected. Clearing bundler cache."
|
|
puts "Old: #{@metadata.read(ruby_version_cache).strip}"
|
|
puts "New: #{full_ruby_version}"
|
|
purge_bundler_cache
|
|
end
|
|
|
|
# fix git gemspec bug from Bundler 1.3.0+ upgrade
|
|
if File.exists?(bundler_cache) && !@metadata.exists?(bundler_version_cache) && !run("find vendor/bundle/*/*/bundler/gems/*/ -name *.gemspec").include?("No such file or directory")
|
|
puts "Old bundler cache detected. Clearing bundler cache."
|
|
purge_bundler_cache
|
|
end
|
|
|
|
# fix for https://github.com/heroku/heroku-buildpack-ruby/issues/86
|
|
if (!@metadata.exists?(rubygems_version_cache) ||
|
|
(old_rubygems_version == "2.0.0" && old_rubygems_version != rubygems_version)) &&
|
|
@metadata.exists?(ruby_version_cache) && @metadata.read(ruby_version_cache).strip.include?("ruby 2.0.0p0")
|
|
puts "Updating to rubygems #{rubygems_version}. Clearing bundler cache."
|
|
purge_bundler_cache
|
|
end
|
|
|
|
# fix for https://github.com/sparklemotion/nokogiri/issues/923
|
|
if @metadata.exists?(buildpack_version_cache) && (bv = @metadata.read(buildpack_version_cache).sub('v', '').to_i) && bv != 0 && bv <= 76
|
|
puts "Fixing nokogiri install. Clearing bundler cache."
|
|
puts "See https://github.com/sparklemotion/nokogiri/issues/923."
|
|
purge_bundler_cache
|
|
end
|
|
|
|
# recompile nokogiri to use new libyaml
|
|
if @metadata.exists?(buildpack_version_cache) && (bv = @metadata.read(buildpack_version_cache).sub('v', '').to_i) && bv != 0 && bv <= 99 && bundler.has_gem?("psych")
|
|
puts "Need to recompile psych for CVE-2013-6393. Clearing bundler cache."
|
|
puts "See http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=737076."
|
|
purge_bundler_cache
|
|
end
|
|
|
|
# recompile gems for libyaml 0.1.7 update
|
|
if @metadata.exists?(buildpack_version_cache) && (bv = @metadata.read(buildpack_version_cache).sub('v', '').to_i) && bv != 0 && bv <= 147 &&
|
|
(@metadata.exists?(ruby_version_cache) && @metadata.read(ruby_version_cache).strip.match(/ruby 2\.1\.(9|10)/) ||
|
|
bundler.has_gem?("psych")
|
|
)
|
|
puts "Need to recompile gems for CVE-2014-2014-9130. Clearing bundler cache."
|
|
puts "See https://devcenter.heroku.com/changelog-items/1016."
|
|
purge_bundler_cache
|
|
end
|
|
|
|
FileUtils.mkdir_p(heroku_metadata)
|
|
@metadata.write(ruby_version_cache, full_ruby_version, false)
|
|
@metadata.write(buildpack_version_cache, BUILDPACK_VERSION, false)
|
|
@metadata.write(bundler_version_cache, bundler.version, false)
|
|
@metadata.write(rubygems_version_cache, rubygems_version, false)
|
|
@metadata.write(stack_cache, @stack, false)
|
|
@metadata.save
|
|
end
|
|
end
|
|
|
|
def purge_bundler_cache(stack = nil)
|
|
instrument "ruby.purge_bundler_cache" do
|
|
@bundler_cache.clear(stack)
|
|
# need to reinstall language pack gems
|
|
install_bundler_in_app(slug_vendor_base)
|
|
end
|
|
end
|
|
end
|