minmb-capistrano 2.15.4

data/lib/capistrano/recipes/deploy/assets.rb

@@ -0,0 +1,201 @@
+require 'json'
+
+load 'deploy' unless defined?(_cset)
+
+_cset :asset_env, "RAILS_GROUPS=assets"
+_cset :assets_prefix, "assets"
+_cset :shared_assets_prefix, "assets"
+_cset :assets_role, [:web]
+_cset :expire_assets_after, (3600 * 24 * 7)
+
+_cset :normalize_asset_timestamps, false
+
+before 'deploy:finalize_update',   'deploy:assets:symlink'
+after  'deploy:update_code',       'deploy:assets:precompile'
+before 'deploy:assets:precompile', 'deploy:assets:update_asset_mtimes'
+after  'deploy:cleanup',           'deploy:assets:clean_expired'
+after  'deploy:rollback:revision', 'deploy:assets:rollback'
+
+def shared_manifest_path
+  @shared_manifest_path ||= capture("ls #{shared_path.shellescape}/#{shared_assets_prefix}/manifest*").strip
+end
+
+# Parses manifest and returns array of uncompressed and compressed asset filenames with and without digests
+# "Intelligently" determines format of string - supports YAML and JSON
+def parse_manifest(str)
+  assets_hash = str[0,1] == '{' ? JSON.parse(str)['assets'] : YAML.load(str)
+
+  assets_hash.to_a.flatten.map {|a| [a, "#{a}.gz"] }.flatten
+end
+
+namespace :deploy do
+  namespace :assets do
+    desc <<-DESC
+      [internal] This task will set up a symlink to the shared directory \
+      for the assets directory. Assets are shared across deploys to avoid \
+      mid-deploy mismatches between old application html asking for assets \
+      and getting a 404 file not found error. The assets cache is shared \
+      for efficiency. If you customize the assets path prefix, override the \
+      :assets_prefix variable to match. If you customize shared assets path \
+      prefix, override :shared_assets_prefix variable to match.
+    DESC
+    task :symlink, :roles => lambda { assets_role }, :except => { :no_release => true } do
+      run <<-CMD.compact
+        rm -rf #{latest_release}/public/#{assets_prefix} &&
+        mkdir -p #{latest_release}/public &&
+        mkdir -p #{shared_path}/#{shared_assets_prefix} &&
+        ln -s #{shared_path}/#{shared_assets_prefix} #{latest_release}/public/#{assets_prefix}
+      CMD
+    end
+
+    desc <<-DESC
+      Run the asset precompilation rake task. You can specify the full path \
+      to the rake executable by setting the rake variable. You can also \
+      specify additional environment variables to pass to rake via the \
+      asset_env variable. The defaults are:
+
+        set :rake,      "rake"
+        set :rails_env, "production"
+        set :asset_env, "RAILS_GROUPS=assets"
+    DESC
+    task :precompile, :roles => lambda { assets_role }, :except => { :no_release => true } do
+      run <<-CMD.compact
+        cd -- #{latest_release} && 
+        RAILS_ENV=#{rails_env.to_s.shellescape} #{asset_env} #{rake} assets:precompile
+      CMD
+
+      if capture("ls -1 #{shared_path.shellescape}/#{shared_assets_prefix}/manifest* | wc -l").to_i > 1
+        raise "More than one asset manifest file was found in '#{shared_path.shellescape}/#{shared_assets_prefix}'.  If you are upgrading a Rails 3 application to Rails 4, follow these instructions: http://github.com/capistrano/capistrano/wiki/Upgrading-to-Rails-4#asset-pipeline"
+      end
+
+      # Sync manifest filenames across servers if our manifest has a random filename
+      if shared_manifest_path =~ /manifest-.+\./
+        run <<-CMD.compact
+          [ -e #{shared_manifest_path.shellescape} ] || mv -- #{shared_path.shellescape}/#{shared_assets_prefix}/manifest* #{shared_manifest_path.shellescape}
+        CMD
+      end
+
+      # Copy manifest to release root (for clean_expired task)
+      run <<-CMD.compact
+        cp -- #{shared_manifest_path.shellescape} #{current_release.to_s.shellescape}/assets_manifest#{File.extname(shared_manifest_path)}
+      CMD
+    end
+
+    desc <<-DESC
+      [internal] Updates the mtimes for assets that are required by the current release.
+      This task runs before assets:precompile.
+    DESC
+    task :update_asset_mtimes, :roles => lambda { assets_role }, :except => { :no_release => true } do
+      # Fetch assets/manifest contents.
+      manifest_content = capture("[ -e #{shared_path.shellescape}/#{shared_assets_prefix}/manifest* ] && cat #{shared_path.shellescape}/#{shared_assets_prefix}/manifest* || echo").strip
+
+      if manifest_content != ""
+        current_assets = parse_manifest(manifest_content)
+        logger.info "Updating mtimes for ~#{current_assets.count} assets..."
+        put current_assets.map{|a| "#{shared_path}/#{shared_assets_prefix}/#{a}" }.join("\n"), "#{deploy_to}/TOUCH_ASSETS", :via => :scp
+        run <<-CMD.compact
+          cat #{deploy_to.shellescape}/TOUCH_ASSETS | while read asset; do
+            touch -c -- "$asset";
+          done &&
+          rm -f -- #{deploy_to.shellescape}/TOUCH_ASSETS
+        CMD
+      end
+    end
+
+    desc <<-DESC
+      Run the asset clean rake task. Use with caution, this will delete \
+      all of your compiled assets. You can specify the full path \
+      to the rake executable by setting the rake variable. You can also \
+      specify additional environment variables to pass to rake via the \
+      asset_env variable. The defaults are:
+
+        set :rake,      "rake"
+        set :rails_env, "production"
+        set :asset_env, "RAILS_GROUPS=assets"
+    DESC
+    task :clean, :roles => lambda { assets_role }, :except => { :no_release => true } do
+      run "cd #{latest_release} && #{rake} RAILS_ENV=#{rails_env} #{asset_env} assets:clean"
+    end
+
+    desc <<-DESC
+      Clean up any assets that haven't been deployed for more than :expire_assets_after seconds.
+      Default time to keep old assets is one week. Set the :expire_assets_after variable
+      to change the assets expiry time. Assets will only be deleted if they are not required by
+      an existing release.
+    DESC
+    task :clean_expired, :roles => lambda { assets_role }, :except => { :no_release => true } do
+      # Fetch all assets_manifest contents.
+      manifests_output = capture <<-CMD.compact
+        for manifest in #{releases_path.shellescape}/*/assets_manifest.*; do
+          cat -- "$manifest" 2> /dev/null && printf ':::' || true;
+        done
+      CMD
+      manifests = manifests_output.split(':::')
+
+      if manifests.empty?
+        logger.info "No manifests in #{releases_path}/*/assets_manifest.*"
+      else
+        logger.info "Fetched #{manifests.count} manifests from #{releases_path}/*/assets_manifest.*"
+        current_assets = Set.new
+        manifests.each do |content|
+          current_assets += parse_manifest(content)
+        end
+        current_assets += [File.basename(shared_manifest_path), "sources_manifest.yml"]
+
+        # Write the list of required assets to server.
+        logger.info "Writing required assets to #{deploy_to}/REQUIRED_ASSETS..."
+        escaped_assets = current_assets.sort.join("\n").gsub("\"", "\\\"") << "\n"
+        put escaped_assets, "#{deploy_to}/REQUIRED_ASSETS", :via => :scp
+
+        # Finds all files older than X minutes, then removes them if they are not referenced
+        # in REQUIRED_ASSETS.
+        expire_after_mins = (expire_assets_after.to_f / 60.0).to_i
+        logger.info "Removing assets that haven't been deployed for #{expire_after_mins} minutes..."
+        # LC_COLLATE=C tells the `sort` and `comm` commands to sort files in byte order.
+        run <<-CMD.compact
+          cd -- #{deploy_to.shellescape}/ &&
+          LC_COLLATE=C sort REQUIRED_ASSETS -o REQUIRED_ASSETS &&
+          cd -- #{shared_path.shellescape}/#{shared_assets_prefix}/ &&
+          for f in $(
+            find * -mmin +#{expire_after_mins.to_s.shellescape} -type f | LC_COLLATE=C sort |
+            LC_COLLATE=C comm -23 -- - #{deploy_to.shellescape}/REQUIRED_ASSETS
+          ); do
+            echo "Removing unneeded asset: $f";
+            rm -f -- "$f";
+          done;
+          rm -f -- #{deploy_to.shellescape}/REQUIRED_ASSETS
+        CMD
+      end
+    end
+
+    desc <<-DESC
+      Rolls back assets to the previous release by symlinking the release's manifest
+      to shared/assets/manifest, and finally recompiling or regenerating nondigest assets.
+    DESC
+    task :rollback, :roles => lambda { assets_role }, :except => { :no_release => true } do
+      previous_manifest = capture("ls #{previous_release.shellescape}/assets_manifest.*").strip
+      if capture("[ -e #{previous_manifest.shellescape} ] && echo true || echo false").strip != 'true'
+        puts "#{previous_manifest} is missing! Cannot roll back assets. " <<
+             "Please run deploy:assets:precompile to update your assets when the rollback is finished."
+      else
+        # If the user is rolling back a Rails 4 app to Rails 3
+        if File.extname(previous_manifest) == '.yml' && File.extname(shared_manifest_path) == '.json'
+          # Remove the existing JSON manifest
+          run "rm -f -- #{shared_manifest_path.shellescape}"
+
+          # Restore the manifest to the Rails 3 path
+          restored_manifest_path = "#{shared_path.shellescape}/#{shared_assets_prefix}/manifest.yml"
+        else
+          # If the user is not rolling back from Rails 4 to 3, we just want to replace the current manifest
+          restored_manifest_path = shared_manifest_path
+        end
+
+        run <<-CMD.compact
+          cd -- #{previous_release.shellescape} &&
+          cp -f -- #{previous_manifest.shellescape} #{restored_manifest_path.shellescape} &&
+          [ -z "$(#{rake} -P | grep assets:precompile:nondigest)" ] || #{rake} RAILS_ENV=#{rails_env.to_s.shellescape} #{asset_env} assets:precompile:nondigest
+        CMD
+      end
+    end
+  end
+end

data/lib/capistrano/recipes/deploy/dependencies.rb

@@ -0,0 +1,44 @@
+require 'capistrano/recipes/deploy/local_dependency'
+require 'capistrano/recipes/deploy/remote_dependency'
+
+module Capistrano
+  module Deploy
+    class Dependencies
+      include Enumerable
+
+      attr_reader :configuration
+
+      def initialize(configuration)
+        @configuration = configuration
+        @dependencies = []
+        yield self if block_given?
+      end
+
+      def check
+        yield self
+        self
+      end
+
+      def remote
+        dep = RemoteDependency.new(configuration)
+        @dependencies << dep
+        dep
+      end
+
+      def local
+        dep = LocalDependency.new(configuration)
+        @dependencies << dep
+        dep
+      end
+
+      def each
+        @dependencies.each { |d| yield d }
+        self
+      end
+
+      def pass?
+        all? { |d| d.pass? }
+      end
+    end
+  end
+end

data/lib/capistrano/recipes/deploy/local_dependency.rb

@@ -0,0 +1,54 @@
+module Capistrano
+  module Deploy
+    class LocalDependency
+      attr_reader :configuration
+      attr_reader :message
+
+      def initialize(configuration)
+        @configuration = configuration
+        @success = true
+      end
+
+      def command(command)
+        @message ||= "`#{command}' could not be found in the path on the local host"
+        @success = find_in_path(command)
+        self
+      end
+
+      def or(message)
+        @message = message
+        self
+      end
+
+      def pass?
+        @success
+      end
+
+    private
+
+      # Searches the path, looking for the given utility. If an executable
+      # file is found that matches the parameter, this returns true.
+      def find_in_path(utility)
+        path = (ENV['PATH'] || "").split(File::PATH_SEPARATOR)
+        suffixes = self.class.on_windows? ? self.class.windows_executable_extensions : [""]
+
+        path.each do |dir|
+          suffixes.each do |sfx|
+            file = File.join(dir, utility + sfx)
+            return true if File.executable?(file)
+          end
+        end
+
+        false
+      end
+
+      def self.on_windows?
+        RUBY_PLATFORM =~ /mswin|mingw/
+      end
+
+      def self.windows_executable_extensions
+        %w(.exe .bat .com .cmd)
+      end
+    end
+  end
+end

data/lib/capistrano/recipes/deploy/remote_dependency.rb

@@ -0,0 +1,117 @@
+require 'capistrano/errors'
+
+module Capistrano
+  module Deploy
+    class RemoteDependency
+      attr_reader :configuration
+      attr_reader :hosts
+
+      def initialize(configuration)
+        @configuration = configuration
+        @success = true
+        @hosts = nil
+      end
+
+      def directory(path, options={})
+        @message ||= "`#{path}' is not a directory"
+        try("test -d #{path}", options)
+        self
+      end
+
+      def file(path, options={})
+        @message ||= "`#{path}' is not a file"
+        try("test -f #{path}", options)
+        self
+      end
+
+      def writable(path, options={})
+        @message ||= "`#{path}' is not writable"
+        try("test -w #{path}", options)
+        self
+      end
+
+      def command(command, options={})
+        @message ||= "`#{command}' could not be found in the path"
+        try("which #{command}", options)
+        self
+      end
+
+      def gem(name, version, options={})
+        @message ||= "gem `#{name}' #{version} could not be found"
+        gem_cmd = configuration.fetch(:gem_command, "gem")
+        try("#{gem_cmd} specification --version '#{version}' #{name} 2>&1 | awk 'BEGIN { s = 0 } /^name:/ { s = 1; exit }; END { if(s == 0) exit 1 }'", options)
+        self
+      end
+
+      def deb(name, version, options={})
+        @message ||= "package `#{name}' #{version} could not be found"
+        try("dpkg -s #{name} | grep '^Version: #{version}'", options)
+        self
+      end
+
+      def rpm(name, version, options={})
+        @message ||= "package `#{name}' #{version} could not be found"
+        try("rpm -q #{name} | grep '#{version}'", options)
+        self
+      end
+
+      def match(command, expect, options={})
+        expect = Regexp.new(Regexp.escape(expect.to_s)) unless expect.is_a?(Regexp)
+
+        output_per_server = {}
+        try("#{command} ", options) do |ch, stream, out|
+          output_per_server[ch[:server]] ||= ''
+          output_per_server[ch[:server]] += out
+        end
+
+        # It is possible for some of these commands to return a status != 0
+        # (for example, rake --version exits with a 1). For this check we
+        # just care if the output matches, so we reset the success flag.
+        @success = true
+
+        errored_hosts = []
+        output_per_server.each_pair do |server, output|
+          next if output =~ expect
+          errored_hosts << server
+        end
+
+        if errored_hosts.any?
+          @hosts = errored_hosts.join(', ')
+          output = output_per_server[errored_hosts.first]
+          @message = "the output #{output.inspect} from #{command.inspect} did not match #{expect.inspect}"
+          @success = false
+        end
+
+        self
+      end
+
+      def or(message)
+        @message = message
+        self
+      end
+
+      def pass?
+        @success
+      end
+
+      def message
+        s = @message.dup
+        s << " (#{@hosts})" if @hosts
+        s
+      end
+
+    private
+
+      def try(command, options)
+        return unless @success # short-circuit evaluation
+        configuration.invoke_command(command, options) do |ch,stream,out|
+          warn "#{ch[:server]}: #{out}" if stream == :err
+          yield ch, stream, out if block_given?
+        end
+      rescue Capistrano::CommandError => e
+        @success = false
+        @hosts = e.hosts.join(', ')
+      end
+    end
+  end
+end

data/lib/capistrano/recipes/deploy/scm.rb

@@ -0,0 +1,19 @@
+module Capistrano
+  module Deploy
+    module SCM
+      def self.new(scm, config={})
+        scm_file = "capistrano/recipes/deploy/scm/#{scm}"
+        require(scm_file)
+
+        scm_const = scm.to_s.capitalize.gsub(/_(.)/) { $1.upcase }
+        if const_defined?(scm_const)
+          const_get(scm_const).new(config)
+        else
+          raise Capistrano::Error, "could not find `#{name}::#{scm_const}' in `#{scm_file}'"
+        end
+      rescue LoadError
+        raise Capistrano::Error, "could not find any SCM named `#{scm}'"
+      end
+    end
+  end
+end

data/lib/capistrano/recipes/deploy/scm/accurev.rb

@@ -0,0 +1,169 @@
+require 'capistrano/recipes/deploy/scm/base'
+require 'rexml/xpath'
+require 'rexml/document'
+
+module Capistrano
+  module Deploy
+    module SCM
+      # Accurev bridge for use by Capistrano. This implementation does not
+      # implement all features of a Capistrano SCM module. The ones that are
+      # left out are either exceedingly difficult to implement with Accurev
+      # or are considered bad form.
+      #
+      # When using this module in a project, the following variables are used:
+      #  * :repository - This should match the depot that code lives in. If your code
+      #                  exists in a subdirectory, you can append the path depot.
+      #                  eg. foo-depot/bar_dir
+      #  * :stream - The stream in the depot that code should be pulled from. If
+      #              left blank, the depot stream will be used
+      #  * :revision - Should be in the form 'stream/transaction'.
+      class Accurev < Base
+        include REXML
+        default_command 'accurev'
+
+        # Defines pseudo-revision value for the most recent changes to be deployed.
+        def head
+          "#{stream}/highest"
+        end
+
+        # Given an Accurev revision identifier, this method returns an identifier that
+        # can be used for later SCM calls. This returned identifier will not
+        # change as a result of further SCM activity.
+        def query_revision(revision)
+          internal_revision = InternalRevision.parse(revision)
+          return revision unless internal_revision.psuedo_revision?
+
+          logger.debug("Querying for real revision for #{internal_revision}")
+          rev_stream = internal_revision.stream
+
+          logger.debug("Determining what type of stream #{rev_stream} is...")
+          stream_xml = yield show_streams_for(rev_stream)
+          stream_doc = Document.new(stream_xml)
+          type = XPath.first(stream_doc, '//streams/stream/@type').value
+
+          case type
+          when 'snapshot'
+            InternalRevision.new(rev_stream, 'highest').to_s
+          else
+            logger.debug("Getting latest transaction id in #{rev_stream}")
+            # Doing another yield for a second Accurev call. Hopefully this is ok.
+            hist_xml = yield scm(:hist, '-ftx', '-s', rev_stream, '-t', 'now.1')
+            hist_doc = Document.new(hist_xml)
+            transaction_id = XPath.first(hist_doc, '//AcResponse/transaction/@id').value
+            InternalRevision.new(stream, transaction_id).to_s
+          end
+        end
+
+        # Pops a copy of the code for the specified Accurev revision identifier.
+        # The revision identifier is represented as a stream & transaction ID combo.
+        # Accurev can only pop a particular transaction if a stream is created on the server
+        # with a time basis of that transaction id. Therefore, we will create a stream with
+        # the required criteria and pop that.
+        def export(revision_id, destination)
+          revision = InternalRevision.parse(revision_id)
+          logger.debug("Exporting #{revision.stream}/#{revision.transaction_id} to #{destination}")
+
+          commands = [
+            change_or_create_stream("#{revision.stream}-capistrano-deploy", revision),
+            "mkdir -p #{destination}",
+            scm_quiet(:pop, "-Rv #{stream}", "-L #{destination}", "'/./#{subdir}'")
+          ]
+          if subdir
+            commands.push(
+              "mv #{destination}/#{subdir}/* #{destination}",
+              "rm -rf #{File.join(destination, subdir)}"
+            )
+          end
+          commands.join(' && ')
+        end
+
+        # Returns the command needed to show the changes that exist between the two revisions.
+        def log(from, to=head)
+          logger.info("Getting transactions between #{from} and #{to}")
+          from_rev = InternalRevision.parse(from)
+          to_rev = InternalRevision.parse(to)
+
+          [
+            scm(:hist, '-s', from_rev.stream, '-t', "#{to_rev.transaction_id}-#{from_rev.transaction_id}"),
+            "sed -e '/transaction #{from_rev.transaction_id}/ { Q }'"
+          ].join(' | ')
+        end
+
+        # Returns the command needed to show the diff between what is deployed and what is
+        # pending. Because Accurev can not do this task without creating some streams,
+        # two time basis streams will be created for the purposes of doing the diff.
+        def diff(from, to=head)
+          from = InternalRevision.parse(from)
+          to = InternalRevision.parse(to)
+
+          from_stream = "#{from.stream}-capistrano-diff-from"
+          to_stream = "#{to.stream}-capistrano-diff-to"
+
+          [
+            change_or_create_stream(from_stream, from),
+            change_or_create_stream(to_stream, to),
+            scm(:diff, '-v', from_stream, '-V', to_stream, '-a')
+          ].join(' && ')
+        end
+
+        private
+        def depot
+          repository.split('/')[0]
+        end
+
+        def stream
+          variable(:stream) || depot
+        end
+
+        def subdir
+          repository.split('/')[1..-1].join('/') unless repository.index('/').nil?
+        end
+
+        def change_or_create_stream(name, revision)
+          [
+            scm_quiet(:mkstream, '-b', revision.stream, '-s', name, '-t', revision.transaction_id),
+            scm_quiet(:chstream, '-b', revision.stream, '-s', name, '-t', revision.transaction_id)
+          ].join('; ')
+        end
+
+        def show_streams_for(stream)
+          scm :show, '-fx', '-s', stream, :streams
+        end
+
+        def scm_quiet(*args)
+          scm(*args) + (variable(:scm_verbose) ? '' : '&> /dev/null')
+        end
+
+        class InternalRevision
+          attr_reader :stream, :transaction_id
+
+          def self.parse(string)
+            match = /([^\/]+)(\/(.+)){0,1}/.match(string)
+            raise "Unrecognized revision identifier: #{string}" unless match
+
+            stream = match[1]
+            transaction_id = match[3] || 'highest'
+            InternalRevision.new(stream, transaction_id)
+          end
+
+          def initialize(stream, transaction_id)
+            @stream = stream
+            @transaction_id = transaction_id
+          end
+
+          def psuedo_revision?
+            @transaction_id == 'highest'
+          end
+
+          def to_s
+            "#{stream}/#{transaction_id}"
+          end
+
+          def ==(other)
+            (stream == other.stream) && (transaction_id == other.transaction_id)
+          end
+        end
+      end
+    end
+  end
+end