Module: EY::Serverside::RailsAssetSupport
- Included in:
- DeployBase
- Defined in:
- lib/engineyard-serverside/rails_asset_support.rb
Instance Method Summary collapse
- #app_builds_own_assets? ⇒ Boolean
- #app_disables_assets?(path) ⇒ Boolean
-
#app_has_asset_task? ⇒ Boolean
Runs ‘rake -T’ to see if there is an assets:precompile task.
- #app_needs_assets? ⇒ Boolean
- #bundled_rails_version(lockfile_path = paths.gemfile_lock) ⇒ Object
- #compile_assets ⇒ Object
-
#keep_existing_assets ⇒ Object
To support operations like Unicorn’s hot reload, it is useful to have the prior release’s assets as well.
Instance Method Details
#app_builds_own_assets? ⇒ Boolean
95 96 97 |
# File 'lib/engineyard-serverside/rails_asset_support.rb', line 95 def app_builds_own_assets? paths.public_assets.exist? end |
#app_disables_assets?(path) ⇒ Boolean
76 77 78 79 80 81 82 83 84 |
# File 'lib/engineyard-serverside/rails_asset_support.rb', line 76 def app_disables_assets?(path) disabled = nil File.open(path) do |fd| pattern = /^[^#].*config\.assets\.enabled\s+=\s+(false|nil)/ contents = fd.read disabled = contents.match(pattern) end disabled end |
#app_has_asset_task? ⇒ Boolean
Runs ‘rake -T’ to see if there is an assets:precompile task.
87 88 89 90 91 92 93 |
# File 'lib/engineyard-serverside/rails_asset_support.rb', line 87 def app_has_asset_task? # We just run this locally on the app master; everybody else should # have the same code anyway. task_check = "PATH=#{paths.binstubs}:$PATH #{config.framework_envs} rake -T assets:precompile |grep 'assets:precompile'" cmd = "cd #{paths.active_release} && #{task_check}" shell.logged_system("cd #{paths.active_release} && #{task_check}").success? end |
#app_needs_assets? ⇒ Boolean
34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 |
# File 'lib/engineyard-serverside/rails_asset_support.rb', line 34 def app_needs_assets? if config.precompile_assets? shell.status "Attempting Rails asset precompilation. (enabled in config)" return true elsif config.skip_precompile_assets? shell.status "Skipping asset precompilation. (disabled in ey.yml)" return false end app_rb_path = paths.active_release_config.join('application.rb') unless app_rb_path.readable? # Not a Rails app in the first place. shell.status "Skipping asset precompilation. (not a Rails application)" return false end if paths.active_release.join('app','assets').exist? shell.status "Attempting Rails asset precompilation. (found directory: 'app/assets')" else shell.status "Skipping asset precompilation. (directory not found: 'app/assets')" return false end if paths.public_assets.exist? shell.status "Skipping asset compilation. Already compiled. (found directory: 'public/assets')" return false end if app_disables_assets?(app_rb_path) shell.status "Skipping asset compilation. (application.rb has disabled asset compilation)" return false end # This check is very expensive, and has been deemed not worth the time. # Leaving this here in case someone comes up with a faster way. #unless app_has_asset_task? # shell.status "No 'assets:precompile' Rake task found. Skipping." # return #end true end |
#bundled_rails_version(lockfile_path = paths.gemfile_lock) ⇒ Object
117 118 119 120 121 122 123 124 125 126 127 128 |
# File 'lib/engineyard-serverside/rails_asset_support.rb', line 117 def bundled_rails_version(lockfile_path = paths.gemfile_lock) return unless lockfile_path.exist? lockfile = lockfile_path.read lockfile.each_line do |line| # scan for gemname (version) toplevel deps. # Likely doesn't handle ancient Bundler versions, but # we only call this when something looks like it is Rails 3. next unless line =~ /^\s{4}([-\w_.0-9]+)\s*\((.*)\)/ return $2 if $1 == 'rails' end nil end |
#compile_assets ⇒ Object
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 |
# File 'lib/engineyard-serverside/rails_asset_support.rb', line 4 def compile_assets return unless app_needs_assets? rails_version = bundled_rails_version roles config.asset_roles do keep_existing_assets cmd = "cd #{paths.active_release} && PATH=#{paths.binstubs}:$PATH #{config.framework_envs} rake assets:precompile RAILS_GROUPS=assets" if rails_version shell.status "Precompiling assets for rails v#{rails_version}" else shell.warning "Precompiling assets even though Rails was not bundled." end begin run(cmd) rescue StandardError => e if config.precompile_assets_inferred? # If specifically requested, then we want to fail if compilation fails. # If we are implicitly precompiling, we want to fail non-destructively # because we don't know if the rake task exists or if the user # actually intended for assets to be compiled. shell.notice "Asset compilation failure ignored.\nAdd 'precompile_assets: true' to ey.yml to abort deploy on failure." return else raise end end end end |
#keep_existing_assets ⇒ Object
To support operations like Unicorn’s hot reload, it is useful to have the prior release’s assets as well. Otherwise, while a deploy is running, clients may request stale assets that you just deleted. Making use of this requires a properly-configured front-end HTTP server.
103 104 105 106 107 108 109 110 111 112 113 114 115 |
# File 'lib/engineyard-serverside/rails_asset_support.rb', line 103 def keep_existing_assets current = paths.shared_assets last_asset_path = paths.shared.join('last_assets') # If there are current shared assets, move them under a 'last_assets' directory. run <<-COMMAND if [ -d #{current} ]; then rm -rf #{last_asset_path} && mkdir #{last_asset_path} && mv #{current} #{last_asset_path} && mkdir -p #{current}; else mkdir -p #{current} #{last_asset_path}; fi; ln -nfs #{current} #{last_asset_path} #{paths.public} COMMAND end |