capistrano 2.8.0 → 3.19.0

data/lib/capistrano/logger.rb

@@ -1,59 +0,0 @@
-module Capistrano
-  class Logger #:nodoc:
-    attr_accessor :level
-    attr_reader   :device
-
-    IMPORTANT = 0
-    INFO      = 1
-    DEBUG     = 2
-    TRACE     = 3
-    
-    MAX_LEVEL = 3
-
-    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 = 0
-    end
-
-    def close
-      device.close if @needs_close
-    end
-
-    def log(level, message, line_prefix=nil)
-      if level <= self.level
-        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
-  end
-end

data/lib/capistrano/processable.rb

@@ -1,53 +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)
-      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: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,57 +0,0 @@
-load 'deploy' unless defined?(_cset)
-
-_cset :asset_env, "RAILS_GROUPS=assets"
-_cset :assets_prefix, "assets"
-
-before 'deploy:finalize_update', 'deploy:assets:symlink'
-after 'deploy:update_code', 'deploy:assets:precompile'
-
-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 cutomize the assets path prefix, override the \
-      :assets_prefix variable to match.
-    DESC
-    task :symlink, :roles => :web, :except => { :no_release => true } do
-      run <<-CMD
-        rm -rf #{latest_release}/public/#{assets_prefix} &&
-        mkdir -p #{latest_release}/public &&
-        mkdir -p #{shared_path}/assets &&
-        ln -s #{shared_path}/assets #{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 => :web, :except => { :no_release => true } do
-      run "cd #{latest_release} && #{rake} RAILS_ENV=#{rails_env} #{asset_env} assets:precompile"
-    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 => :web, :except => { :no_release => true } do
-      run "cd #{latest_release} && #{rake} RAILS_ENV=#{rails_env} #{asset_env} assets:clean"
-    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,111 +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 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/accurev.rb

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