capistrano 2.15.11 → 3.0.0.pre

data/lib/capistrano/logger.rb

@@ -1,166 +0,0 @@
-module Capistrano
-  class Logger #:nodoc:
-    attr_accessor :level, :device, :disable_formatters
-
-    IMPORTANT = 0
-    INFO      = 1
-    DEBUG     = 2
-    TRACE     = 3
-
-    MAX_LEVEL = 3
-
-    COLORS = {
-      :none     => "0",
-      :black    => "30",
-      :red      => "31",
-      :green    => "32",
-      :yellow   => "33",
-      :blue     => "34",
-      :magenta  => "35",
-      :cyan     => "36",
-      :white    => "37"
-    }
-
-    STYLES = {
-      :bright     => 1,
-      :dim        => 2,
-      :underscore => 4,
-      :blink      => 5,
-      :reverse    => 7,
-      :hidden     => 8
-    }
-
-    # Set up default formatters
-    @default_formatters = [
-      # TRACE
-      { :match => /command finished/,          :color => :white,   :style => :dim, :level => 3, :priority => -10 },
-      { :match => /executing locally/,         :color => :yellow,  :level => 3, :priority => -20 },
-
-      # DEBUG
-      { :match => /executing `.*/,             :color => :green,   :level => 2, :priority => -10, :timestamp => true },
-      { :match => /.*/,                        :color => :yellow,  :level => 2, :priority => -30 },
-
-      # INFO
-      { :match => /.*out\] (fatal:|ERROR:).*/, :color => :red,     :level => 1, :priority => -10 },
-      { :match => /Permission denied/,         :color => :red,     :level => 1, :priority => -20 },
-      { :match => /sh: .+: command not found/, :color => :magenta, :level => 1, :priority => -30 },
-
-      # IMPORTANT
-      { :match => /^err ::/,                   :color => :red,     :level => 0, :priority => -10 },
-      { :match => /.*/,                        :color => :blue,    :level => 0, :priority => -20 }
-    ]
-    @formatters = @default_formatters
-
-    class << self
-      def default_formatters
-        @default_formatters
-      end
-
-      def default_formatters=(defaults=nil)
-        @default_formatters = [defaults].flatten
-
-        # reset the formatters
-        @formatters = @default_formatters
-        @sorted_formatters = nil
-      end
-
-      def add_formatter(options) #:nodoc:
-        @formatters.push(options)
-        @sorted_formatters = nil
-      end
-
-      def sorted_formatters
-        # Sort matchers in reverse order so we can break if we found a match.
-        @sorted_formatters ||= @formatters.sort_by { |i| -(i[:priority] || i[:prio] || 0) }
-      end
-    end
-
-    def initialize(options={})
-      output = options[:output] || $stderr
-      if output.respond_to?(:puts)
-        @device = output
-      else
-        @device = File.open(output.to_str, "a")
-        @needs_close = true
-      end
-
-      @options = options
-      @level = options[:level] || 0
-      @disable_formatters = options[:disable_formatters]
-    end
-
-    def close
-      device.close if @needs_close
-    end
-
-    def log(level, message, line_prefix=nil)
-      if level <= self.level
-        # Only format output if device is a TTY and formatters are not disabled
-        if device.tty? && !@disable_formatters
-          color = :none
-          style = nil
-
-          Logger.sorted_formatters.each do |formatter|
-            if (formatter[:level] == level || formatter[:level].nil?)
-              if message =~ formatter[:match] || formatter[:match] =~ line_prefix.to_s
-                color = formatter[:color] if formatter[:color]
-                style = formatter[:style] || formatter[:attribute] # (support original cap colors)
-                message.gsub!(formatter[:match], formatter[:replace]) if formatter[:replace]
-                message = formatter[:prepend] + message unless formatter[:prepend].nil?
-                message = message + formatter[:append] unless formatter[:append].nil?
-                message = Time.now.strftime('%Y-%m-%d %T') + ' ' + message if formatter[:timestamp]
-                break unless formatter[:replace]
-              end
-            end
-          end
-
-          if color == :hide
-            # Don't do anything if color is set to :hide
-            return false
-          end
-
-          term_color = COLORS[color]
-          term_style = STYLES[style]
-
-          # Don't format message if no color or style
-          unless color == :none and style.nil?
-            unless line_prefix.nil?
-              line_prefix = format(line_prefix, term_color, term_style, nil)
-            end
-            message = format(message, term_color, term_style)
-          end
-        end
-
-        indent = "%*s" % [MAX_LEVEL, "*" * (MAX_LEVEL - level)]
-        (RUBY_VERSION >= "1.9" ? message.lines : message).each do |line|
-          if line_prefix
-            device.puts "#{indent} [#{line_prefix}] #{line.strip}\n"
-          else
-            device.puts "#{indent} #{line.strip}\n"
-          end
-        end
-      end
-    end
-
-    def important(message, line_prefix=nil)
-      log(IMPORTANT, message, line_prefix)
-    end
-
-    def info(message, line_prefix=nil)
-      log(INFO, message, line_prefix)
-    end
-
-    def debug(message, line_prefix=nil)
-      log(DEBUG, message, line_prefix)
-    end
-
-    def trace(message, line_prefix=nil)
-      log(TRACE, message, line_prefix)
-    end
-
-    def format(message, color, style, nl = "\n")
-      style = "#{style};" if style
-      "\e[#{style}#{color}m" + message.to_s.strip + "\e[0m#{nl}"
-    end
-  end
-end

data/lib/capistrano/processable.rb

@@ -1,55 +0,0 @@
-module Capistrano
-  module Processable
-    module SessionAssociation
-      def self.on(exception, session)
-        unless exception.respond_to?(:session)
-          exception.extend(self)
-          exception.session = session
-        end
-
-        return exception
-      end
-
-      attr_accessor :session
-    end
-
-    def process_iteration(wait=nil, &block)
-      ensure_each_session { |session| session.preprocess }
-
-      return false if block && !block.call(self)
-
-      readers = sessions.map { |session| session.listeners.keys }.flatten.reject { |io| io.closed? }
-      writers = readers.select { |io| io.respond_to?(:pending_write?) && io.pending_write? }
-
-      if readers.any? || writers.any?
-        readers, writers, = IO.select(readers, writers, nil, wait)
-      else
-        return false
-      end
-
-      if readers
-        ensure_each_session do |session|
-          ios = session.listeners.keys
-          session.postprocess(ios & readers, ios & writers)
-        end
-      end
-
-      true
-    end
-
-    def ensure_each_session
-      errors = []
-
-      sessions.each do |session|
-        begin
-          yield session
-        rescue Exception => error
-          errors << SessionAssociation.on(error, session)
-        end
-      end
-
-      raise errors.first if errors.any?
-      sessions
-    end
-  end
-end

data/lib/capistrano/recipes/compat.rb

@@ -1,32 +0,0 @@
-# A collection of compatibility scripts, to ease the transition between
-# Capistrano 1.x and Capistrano 2.x.
-
-# Depends on the deployment system
-load 'deploy'
-
-map = { "diff_from_last_deploy"  => "deploy:pending:diff",
-        "update"                 => "deploy:update",
-        "update_code"            => "deploy:update_code",
-        "symlink"                => "deploy:create_symlink",
-        "restart"                => "deploy:restart",
-        "rollback"               => "deploy:rollback",
-        "cleanup"                => "deploy:cleanup",
-        "disable_web"            => "deploy:web:disable",
-        "enable_web"             => "deploy:web:enable",
-        "cold_deploy"            => "deploy:cold",
-        "deploy_with_migrations" => "deploy:migrations" }
-
-map.each do |old, new|
-  desc "DEPRECATED: See #{new}."
-  eval "task(#{old.inspect}) do
-    warn \"[DEPRECATED] `#{old}' is deprecated. Use `#{new}' instead.\"
-    find_and_execute_task(#{new.inspect})
-  end"
-end
-
-desc "DEPRECATED: See deploy:start."
-task :spinner do
-  warn "[DEPRECATED] `spinner' is deprecated. Use `deploy:start' instead."
-  set :runner, fetch(:spinner_user, "app")
-  deploy.start
-end

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

@@ -1,202 +0,0 @@
-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(:asset_manifest_prefix) { (`sprockets -v`.chomp < "3.0" ? "manifest" : ".sprockets-manifest") rescue "manifest" }
-
-_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}/#{asset_manifest_prefix}*").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}/#{asset_manifest_prefix}* | 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 =~ /#{asset_manifest_prefix}-.+\./
-        run <<-CMD.compact
-          [ -e #{shared_manifest_path.shellescape} ] || mv -- #{shared_path.shellescape}/#{shared_assets_prefix}/#{asset_manifest_prefix}* #{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}/#{asset_manifest_prefix}*' ] && cat #{shared_path.shellescape}/#{shared_assets_prefix}/#{asset_manifest_prefix}* || 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

@@ -1,44 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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