capistrano 2.1.0 → 3.0.0

data/lib/capistrano/gateway.rb

@@ -1,131 +0,0 @@
-if RUBY_VERSION == "1.8.6"
-  begin
-    require 'fastthread'
-  rescue LoadError
-    warn "You are running Ruby 1.8.6, which has a bug in its threading implementation."
-    warn "You are liable to encounter deadlocks running Capistrano, unless you install"
-    warn "the fastthread library, which is available as a gem:"
-    warn "   gem install fastthread"
-  end
-end
-
-require 'thread'
-require 'capistrano/errors'
-require 'capistrano/ssh'
-require 'capistrano/server_definition'
-
-Thread.abort_on_exception = true
-
-module Capistrano
-
-  # Black magic. It uses threads and Net::SSH to set up a connection to a
-  # gateway server, through which connections to other servers may be
-  # tunnelled.
-  #
-  # It is used internally by Capistrano, but may be useful on its own, as well.
-  #
-  # Usage:
-  #
-  #   gateway = Capistrano::Gateway.new(Capistrano::ServerDefinition.new('gateway.example.com'))
-  #
-  #   sess1 = gateway.connect_to(Capistrano::ServerDefinition.new('hidden.example.com'))
-  #   sess2 = gateway.connect_to(Capistrano::ServerDefinition.new('other.example.com'))
-  class Gateway
-    # The Thread instance driving the gateway connection.
-    attr_reader :thread
-
-    # The Net::SSH session representing the gateway connection.
-    attr_reader :session
-
-    MAX_PORT = 65535
-    MIN_PORT = 1024
-
-    def initialize(server, options={}) #:nodoc:
-      @options = options
-      @next_port = MAX_PORT
-      @terminate_thread = false
-      @port_guard = Mutex.new
-
-      mutex = Mutex.new
-      waiter = ConditionVariable.new
-
-      mutex.synchronize do
-        @thread = Thread.new do
-          logger.trace "starting connection to gateway `#{server}'" if logger
-          SSH.connect(server, @options) do |@session|
-            logger.trace "gateway connection established" if logger
-            mutex.synchronize { waiter.signal }
-            @session.loop do
-              !@terminate_thread
-            end
-          end
-        end
-
-        waiter.wait(mutex)
-      end
-    end
-
-    # Shuts down all forwarded connections and terminates the gateway.
-    def shutdown!
-      # cancel all active forward channels
-      session.forward.active_locals.each do |lport, host, port|
-        session.forward.cancel_local(lport)
-      end
-
-      # terminate the gateway thread
-      @terminate_thread = true
-
-      # wait for the gateway thread to stop
-      thread.join
-    end
-
-    # Connects to the given server by opening a forwarded port from the local
-    # host to the server, via the gateway, and then opens and returns a new
-    # Net::SSH connection via that port.
-    def connect_to(server)
-      connection = nil
-      logger.debug "establishing connection to `#{server}' via gateway" if logger
-      local_port = next_port
-
-      thread = Thread.new do
-        begin
-          local_host = ServerDefinition.new("127.0.0.1", :user => server.user, :port => local_port)
-          session.forward.local(local_port, server.host, server.port || 22)
-          connection = SSH.connect(local_host, @options)
-          connection.xserver = server
-          logger.trace "connected: `#{server}' (via gateway)" if logger
-        rescue Errno::EADDRINUSE
-          local_port = next_port
-          retry
-        rescue Exception => e
-          warn "#{e.class}: #{e.message}"
-          warn e.backtrace.join("\n")
-        end
-      end
-
-      thread.join
-      if connection.nil?
-        error = ConnectionError.new("could not establish connection to `#{server}'")
-        error.hosts = [server]
-        raise error
-      end
-    
-      connection
-    end
-
-    private
-
-      def logger
-        @options[:logger]
-      end
-
-      def next_port
-        @port_guard.synchronize do
-          port = @next_port
-          @next_port -= 1
-          @next_port = MAX_PORT if @next_port < MIN_PORT
-          port
-        end
-      end
-  end
-end

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)]
-        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/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/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,46 +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 = RUBY_PLATFORM =~ /mswin/ ? %w(.bat .exe .com .cmd) : [""]
-
-        path.each do |dir|
-          suffixes.each do |sfx|
-            file = File.join(dir, utility + sfx)
-            return true if File.executable?(file)
-          end
-        end
-
-        false
-      end
-    end
-  end
-end

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

@@ -1,96 +0,0 @@
-module Capistrano
-  module Deploy
-    class RemoteDependency
-      attr_reader :configuration
-      attr_reader :hosts
-
-      def initialize(configuration)
-        @configuration = configuration
-        @success = true
-      end
-
-      def directory(path, options={})
-        @message ||= "`#{path}' is not a directory"
-        try("test -d #{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 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 && @hosts.any?
-        s
-      end
-
-    private
-
-      def try(command, options)
-        return unless @success # short-circuit evaluation
-        configuration.run(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