capistrano 1.4.2 → 2.0.0

data/lib/capistrano/recipes/templates/maintenance.rhtml

@@ -43,7 +43,7 @@
            as of <%= Time.now.strftime("%H:%M %Z") %>.
          </p>
          <p style="color: #666;">
-           It'll be back <%= deadline ? "by #{deadline}" : "shortly" %>.
+           It'll be back <%= deadline ? deadline : "shortly" %>.
          </p>
        </div>
      </div>

data/lib/capistrano/recipes/upgrade.rb

@@ -0,0 +1,33 @@
+# Tasks to aid the migration of an established Capistrano 1.x installation to
+# Capistrano 2.x.
+
+namespace :upgrade do
+  desc <<-DESC
+    Migrate from the revisions log to REVISION. Capistrano 1.x recorded each \
+    deployment to a revisions.log file. Capistrano 2.x is cleaner, and just \
+    puts a REVISION file in the root of the deployed revision. This task \
+    migrates from the revisions.log used in Capistrano 1.x, to the REVISION \
+    tag file used in Capistrano 2.x. It is non-destructive and may be safely \
+    run any number of times.
+  DESC
+  task :revisions do
+    revisions = capture("cat #{deploy_to}/revisions.log")
+
+    mapping = {}
+    revisions.each do |line|
+      revision, directory = line.chomp.split[-2,2]
+      mapping[directory] = revision
+    end
+
+    commands = mapping.keys.map do |directory|
+      "echo '.'; test -d #{directory} && echo '#{mapping[directory]}' > #{directory}/REVISION"
+    end
+
+    command = commands.join(";")
+
+    run "cd #{releases_path}; #{command}; true" do |ch, stream, out|
+      STDOUT.print(".")
+      STDOUT.flush
+    end
+  end
+end

data/lib/capistrano/server_definition.rb

@@ -0,0 +1,51 @@
+module Capistrano
+  class ServerDefinition
+    include Comparable
+
+    attr_reader :host
+    attr_reader :user
+    attr_reader :port
+    attr_reader :options
+
+    def initialize(string, options={})
+      @user, @host, @port = string.match(/^(?:([^;,:=]+)@|)(.*?)(?::(\d+)|)$/)[1,3]
+
+      @options = options.dup
+      user_opt, port_opt = @options.delete(:user), @options.delete(:port)
+
+      @user ||= user_opt
+      @port ||= port_opt
+
+      @port = @port.to_i if @port
+    end
+
+    def <=>(server)
+      [host, port, user] <=> [server.host, server.port, server.user]
+    end
+
+    # Redefined, so that Array#uniq will work to remove duplicate server
+    # definitions, based solely on their host names.
+    def eql?(server)
+      host == server.host &&
+        user == server.user &&
+        port == server.port
+    end
+
+    alias :== :eql?
+
+    # Redefined, so that Array#uniq will work to remove duplicate server
+    # definitions, based on their connection information.
+    def hash
+      @hash ||= [host, user, port].hash
+    end
+
+    def to_s
+      @to_s ||= begin
+        s = host
+        s = "#{user}@#{s}" if user
+        s = "#{s}:#{port}" if port && port != 22
+        s
+      end
+    end
+  end
+end

data/lib/capistrano/shell.rb

@@ -1,23 +1,34 @@
 require 'thread'
 
-# The Capistrano::Shell class is the guts of the "shell" task. It implements
-# an interactive REPL interface that users can employ to execute tasks and
-# commands. It makes for a GREAT way to monitor systems, and perform quick
-# maintenance on one or more machines.
-
 module Capistrano
+  # The Capistrano::Shell class is the guts of the "shell" task. It implements
+  # an interactive REPL interface that users can employ to execute tasks and
+  # commands. It makes for a GREAT way to monitor systems, and perform quick
+  # maintenance on one or more machines.
   class Shell
-    # The actor instance employed by this shell
-    attr_reader :actor
+    # A Readline replacement for platforms where readline is either
+    # unavailable, or has not been installed.
+    class ReadlineFallback #:nodoc:
+      HISTORY = []
+
+      def self.readline(prompt)
+        STDOUT.print(prompt)
+        STDOUT.flush
+        STDIN.gets
+      end
+    end
+
+    # The configuration instance employed by this shell
+    attr_reader :configuration
 
     # Instantiate a new shell and begin executing it immediately.
-    def self.run!(actor)
-      new(actor).run!
+    def self.run(config)
+      new(config).run!
     end
 
     # Instantiate a new shell
-    def initialize(actor)
-      @actor = actor
+    def initialize(config)
+      @configuration = config
     end
 
     # Start the shell running. This method will block until the shell
@@ -28,78 +39,88 @@ module Capistrano
       puts <<-INTRO
 ====================================================================
 Welcome to the interactive Capistrano shell! This is an experimental
-feature, and is liable to change in future releases.
+feature, and is liable to change in future releases. Type 'help' for
+a summary of how to use the shell.
 --------------------------------------------------------------------
 INTRO
 
       loop do
-        command = @reader.readline("cap> ", true)
-
-        case command ? command.strip : command
-          when "" then next
-          when "help"  then help
-          when nil, "quit", "exit" then
-            puts if command.nil?
-            puts "exiting"
-            break
-          when /^set -(\w)\s*(\S+)/
-            set_option($1, $2)
-          when /^(?:(with|on)\s*(\S+))?\s*(\S.*)?/i
-            process_command($1, $2, $3)
-          else
-            raise "eh?"
-        end
+        break if !read_and_execute
       end
 
       @bgthread.kill
     end
 
+    def read_and_execute
+      command = read_line
+
+      case command
+        when "?", "help" then help
+        when "quit", "exit" then
+          puts "exiting"
+          return false
+        when /^set -(\w)\s*(\S+)/
+          set_option($1, $2)
+        when /^(?:(with|on)\s*(\S+))?\s*(\S.*)?/i
+          process_command($1, $2, $3)
+        else
+          raise "eh?"
+      end
+
+      return true
+    end
+
     private
 
-      # A Readline replacement for platforms where readline is either
-      # unavailable, or has not been installed.
-      class ReadlineFallback
-        def self.readline(prompt, *args)
-          STDOUT.print(prompt)
-          STDOUT.flush
-          STDIN.gets
+      # Present the prompt and read a single line from the console. It also
+      # detects ^D and returns "exit" in that case. Adds the input to the
+      # history, unless the input is empty. Loops repeatedly until a non-empty
+      # line is input.
+      def read_line
+        loop do
+          command = reader.readline("cap> ")
+
+          if command.nil?
+            command = "exit"
+            puts(command)
+          else
+            command.strip!
+          end
+
+          unless command.empty?
+            reader::HISTORY << command
+            return command
+          end
         end
       end
 
       # Display a verbose help message.
       def help
         puts <<-HELP
-Welcome to the interactive Capistrano shell! To quit, just type quit,
-or exit. Or press ctrl-D. This shell is still experimental, so expect
-it to change (or even disappear!) in future releases.
+--- HELP! ---------------------------------------------------
+"Get me out of this thing. I just want to quit."
+-> Easy enough. Just type "exit", or "quit". Or press ctrl-D.
 
-To execute a command on all servers, just type it directly, like:
+"I want to execute a command on all servers."
+-> Just type the command, and press enter. It will be passed,
+   verbatim, to all defined servers.
 
-  cap> echo ping
+"What if I only want it to execute on a subset of them?"
+-> No problem, just specify the list of servers, separated by
+   commas, before the command, with the `on' keyword:
 
-To execute a command on a specific set of servers, specify an 'on' clause.
-Note that if you specify more than one host name, they must be comma-
-delimited, with NO SPACES between them.
+   cap> on app1.foo.com,app2.foo.com echo ping
 
-  cap> on app1.foo.com,app2.foo.com echo ping
+"Nice, but can I specify the servers by role?"
+-> You sure can. Just use the `with' keyword, followed by the
+   comma-delimited list of role names:
 
-To execute a command on all servers matching a set of roles:
+   cap> with app,db echo ping
 
-  cap> with app,db echo ping
+"Can I execute a Capistrano task from within this shell?"
+-> Yup. Just prefix the task with an exclamation mark:
 
-To execute a Capistrano task, prefix the name with a bang:
-
-  cap> !deploy
-
-You can specify multiple tasks to execute, separated by spaces:
-
-  cap> !update_code symlink
-
-And, lastly, you can specify 'on' or 'with' with tasks:
-
-  cap> on app6.foo.com !setup
-
-Enjoy!  
+   cap> !deploy
 HELP
       end
 
@@ -107,11 +128,11 @@ HELP
       # establish connections to them if necessary. Return the list of
       # servers (names).
       def connect(task)
-        servers = task.servers(:refresh)
-        needing_connections = servers - actor.sessions.keys
+        servers = configuration.find_servers_for_task(task)
+        needing_connections = servers - configuration.sessions.keys
         unless needing_connections.empty?
           puts "[establishing connection(s) to #{needing_connections.join(', ')}]"
-          actor.send(:establish_connections, servers)
+          configuration.establish_connections_to(needing_connections)
         end
         servers
       end
@@ -124,7 +145,7 @@ HELP
         if command[0] == ?!
           exec_tasks(command[1..-1].split)
         else
-          servers = connect(actor.current_task)
+          servers = connect(configuration.current_task)
           exec_command(command, servers)
         end
       ensure
@@ -134,10 +155,13 @@ HELP
       # Given an array of task names, invoke them in sequence.
       def exec_tasks(list)
         list.each do |task_name|
-          task = task_name.to_sym
-          connect(actor.tasks[task])
-          actor.send(task)
+          task = configuration.find_task(task_name)
+          raise Capistrano::NoSuchTaskError, "no such task `#{task_name}'" unless task
+          connect(task)
+          configuration.execute_task(task)
         end
+      rescue Capistrano::NoMatchingServersError, Capistrano::NoSuchTaskError => error
+        warn "error: #{error.message}"
       end
 
       # Execute a command on the given list of servers.
@@ -147,36 +171,45 @@ HELP
           out.each do |line|
             if stream == :out
               if out =~ /Password:\s*/i
-                ch.send_data "#{actor.password}\n"
+                ch.send_data "#{configuration[:password]}\n"
               else
-                puts "[#{ch[:host]}] #{line.chomp}"
+                puts "[#{ch[:server]}] #{line.chomp}"
               end
             elsif stream == :err
-              puts "[#{ch[:host]} ERR] #{line.chomp}"
+              puts "[#{ch[:server]} ERR] #{line.chomp}"
             end
           end
         end
 
-        cmd = Command.new(servers, command, processor, {}, actor)
         previous = trap("INT") { cmd.stop! }
-        cmd.process! rescue nil
+        sessions = servers.map { |server| configuration.sessions[server] }
+        Command.process(command, sessions, :logger => configuration.logger, &Capistrano::Configuration.default_io_proc)
+      rescue Capistrano::Error => error
+        warn "error: #{error.message}"
+      ensure
         trap("INT", previous)
       end
 
-      # Prepare every little thing for the shell. Starts the background
-      # thread and generally gets things ready for the REPL.
-      def setup
-        begin
+      # Return the object that will be used to query input from the console.
+      # The returned object will quack (more or less) like Readline.
+      def reader
+        @reader ||= begin
           require 'readline'
-          @reader = Readline
+          Readline
         rescue LoadError
-          @reader = ReadlineFallback
+          ReadlineFallback
         end
+      end
+
+      # Prepare every little thing for the shell. Starts the background
+      # thread and generally gets things ready for the REPL.
+      def setup
+        configuration.logger.level = Capistrano::Logger::INFO
 
         @mutex = Mutex.new
         @bgthread = Thread.new do
             loop do
-              ready = actor.sessions.values.select { |sess| sess.connection.reader_ready? }
+              ready = configuration.sessions.values.select { |sess| sess.connection.reader_ready? }
               if ready.empty?
                 sleep 0.1
               else
@@ -193,9 +226,20 @@ HELP
         case opt
           when "v" then
             puts "setting log verbosity to #{value.to_i}"
-            actor.logger.level = value.to_i
+            configuration.logger.level = value.to_i
+          when "o" then
+            case value
+            when "vi" then
+              puts "using vi edit mode"
+              reader.vi_editing_mode
+            when "emacs" then
+              puts "using emacs edit mode"
+              reader.emacs_editing_mode
+            else
+              puts "unknown -o option #{value.inspect}"
+            end
           else
-            puts "unknown setting #{value.inspect}"
+            puts "unknown setting #{opt.inspect}"
         end
       end
 
@@ -220,5 +264,5 @@ HELP
           puts "scoping #{scope_type} #{scope_value}"
         end
       end
-  end
+    end
 end

data/lib/capistrano/ssh.rb

@@ -1,9 +1,3 @@
-begin
-  require 'rubygems'
-  gem 'net-ssh', '< 1.99.0'
-rescue LoadError, NameError
-end
-
 require 'net/ssh'
 
 module Capistrano
@@ -11,55 +5,105 @@ module Capistrano
     require 'capistrano/version'
     require 'net/ssh/version'
     ssh_version = [Net::SSH::Version::MAJOR, Net::SSH::Version::MINOR, Net::SSH::Version::TINY]
-    if !Version.check(ssh_version, Version::MINIMUM_SSH_REQUIRED, Version::MAXIMUM_SSH_REQUIRED)
-      raise "You have Net::SSH #{ssh_version.join(".")}, but you need a version between #{Version::MINIMUM_SSH_REQUIRED.join(".")}...#{Version::MAXIMUM_SSH_REQUIRED.join(".")}"
+    if !Version.check(Version::SSH_REQUIRED, ssh_version)
+      raise "You have Net::SSH #{ssh_version.join(".")}, but you need at least #{Version::SSH_REQUIRED.join(".")}"
+    end
+  end
+
+  # Now, Net::SSH is kind of silly, and tries to lazy-load everything. This
+  # wreaks havoc with the parallel connection trick that Capistrano wants to
+  # use, so we're going to do something hideously ugly here and force all the
+  # files that Net::SSH uses to load RIGHT NOW, rather than lazily.
+
+  net_ssh_dependencies = %w(connection/services connection/channel connection/driver
+    service/agentforward/services service/agentforward/driver
+    service/process/driver util/prompter
+    service/forward/services service/forward/driver service/forward/local-network-handler service/forward/remote-network-handler
+    service/shell/services service/shell/driver
+    lenient-host-key-verifier
+    transport/compress/services transport/compress/zlib-compressor transport/compress/none-compressor transport/compress/zlib-decompressor transport/compress/none-decompressor
+    transport/kex/services transport/kex/dh transport/kex/dh-gex
+    transport/ossl/services
+    transport/ossl/hmac/services transport/ossl/hmac/sha1 transport/ossl/hmac/sha1-96 transport/ossl/hmac/md5 transport/ossl/hmac/md5-96 transport/ossl/hmac/none
+    transport/ossl/cipher-factory transport/ossl/hmac-factory transport/ossl/buffer-factory transport/ossl/key-factory transport/ossl/digest-factory
+    transport/identity-cipher transport/packet-stream transport/version-negotiator transport/algorithm-negotiator transport/session
+    userauth/methods/services userauth/methods/password userauth/methods/keyboard-interactive userauth/methods/publickey userauth/methods/hostbased
+    userauth/services userauth/agent userauth/userkeys userauth/driver
+    transport/services service/services
+  )
+
+  net_ssh_dependencies << "userauth/pageant" if File::ALT_SEPARATOR
+  net_ssh_dependencies.each do |path|
+    begin
+      require "net/ssh/#{path}"
+    rescue LoadError
+      # Ignore load errors from this, since some files are in the list which
+      # do not exist in different (supported) versions of Net::SSH. We know
+      # (by this point) that Net::SSH is installed, though, since we do a
+      # require 'net/ssh' at the very top of this file, and we know the
+      # installed version meets the minimum version requirements because of
+      # the version check, also at the top of this file. So, if we get a
+      # LoadError, it's simply because the file in question does not exist in
+      # the version of Net::SSH that is installed.
+      #
+      # Whew!
     end
   end
 
   # A helper class for dealing with SSH connections.
   class SSH
+    # Patch an accessor onto an SSH connection so that we can record the server
+    # definition object that defines the connection. This is useful because
+    # the gateway returns connections whose "host" is 127.0.0.1, instead of
+    # the host on the other side of the tunnel.
+    module Server #:nodoc:
+      def self.apply_to(connection, server)
+        connection.extend(Server)
+        connection.xserver = server
+        connection
+      end
+
+      attr_accessor :xserver
+    end
+
+    # The default port for SSH.
+    DEFAULT_PORT = 22
+
     # An abstraction to make it possible to connect to the server via public key
     # without prompting for the password. If the public key authentication fails
     # this will fall back to password authentication.
     #
+    # +server+ must be an instance of ServerDefinition.
+    #
     # If a block is given, the new session is yielded to it, otherwise the new
     # session is returned.
-    def self.connect(server, config, port=22, &block)
+    #
+    # If an :ssh_options key exists in +options+, it is passed to the Net::SSH
+    # constructor. Values in +options+ are then merged into it, and any
+    # connection information in +server+ is added last, so that +server+ info
+    # takes precedence over +options+, which takes precendence over ssh_options.
+    def self.connect(server, options={}, &block)
       methods = [ %w(publickey hostbased), %w(password keyboard-interactive) ]
       password_value = nil
       
-      user, server_stripped, pport = parse_server(server)       
+      ssh_options = (options[:ssh_options] || {}).dup
+      ssh_options[:username] = server.user || options[:user] || ssh_options[:username]
+      ssh_options[:port]     = server.port || options[:port] || ssh_options[:port] || DEFAULT_PORT
 
       begin
-        ssh_options = { :username => (user || config.user),
-                        :password => password_value,
-                        :port => ((pport && pport != port) ? pport : port),
-                        :auth_methods => methods.shift }.merge(config.ssh_options)
-        
-        Net::SSH.start(server_stripped,ssh_options,&block)
+        connection_options = ssh_options.merge(
+          :password => password_value,
+          :auth_methods => ssh_options[:auth_methods] || methods.shift
+        )
+
+        connection = Net::SSH.start(server.host, connection_options, &block)
+        Server.apply_to(connection, server)
+
       rescue Net::SSH::AuthenticationFailed
-        raise if methods.empty?
-        password_value = config.password
+        raise if methods.empty? || ssh_options[:auth_methods]
+        password_value = options[:password]
         retry
       end
     end
-    
-    # This regex is used for its byproducts, the $1-3 match vars.
-    # This regex will always match the ssh hostname and if there 
-    # is a username or port they will be matched as well. This 
-    # allows us to set the username and ssh port right in the 
-    # server string:  "username@123.12.123.12:8088"
-    # This remains fully backwards compatible and can still be
-    # intermixed with the old way of doing things. usernames
-    # and ports will be used from the server string if present
-    # but they will fall back to the regular defaults when not
-    # present. Returns and array like:
-    # ['bob', 'demo.server.com', '8088']
-    # will always at least return the server:
-    # [nil, 'demo.server.com', nil]
-    def self.parse_server(server)
-      server =~ /^(?:([^;,:=]+)@|)(.*?)(?::(\d+)|)$/
-      [$1, $2, $3]
-    end  
   end
 end