capistrano 2.0.0 → 2.1.0

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

@@ -114,6 +114,18 @@ module Capistrano
           raise NotImplementedError, "`query_revision' is not implemented by #{self.class.name}"
         end
 
+        # Returns the revision number immediately following revision, if at
+        # all possible. A block should always be passed to this method, which
+        # accepts a command to invoke and returns the result, although a
+        # particular SCM's implementation is not required to invoke the block.
+        #
+        # By default, this method simply returns the revision itself. If a
+        # particular SCM is able to determine a subsequent revision given a
+        # revision identifier, it should override this method.
+        def next_revision(revision)
+          revision
+        end
+
         # Should analyze the given text and determine whether or not a
         # response is expected, and if so, return the appropriate response.
         # If no response is expected, return nil. The +state+ parameter is a

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

@@ -0,0 +1,191 @@
+require 'capistrano/recipes/deploy/scm/base'
+
+module Capistrano
+  module Deploy
+    module SCM
+
+      # An SCM module for using Git as your source control tool with Capistrano
+      # 2.0.  If you are using Capistrano 1.x, use this plugin instead:
+      #
+      #   http://scie.nti.st/2007/3/16/capistrano-with-git-shared-repository
+      #
+      # Assumes you are using a shared Git repository.
+      #
+      # Parts of this plugin borrowed from Scott Chacon's version, which I
+      # found on the Capistrano mailing list but failed to be able to get
+      # working.
+      #
+      # FEATURES:
+      #
+      #   * Very simple, only requiring 2 lines in your deploy.rb.
+      #   * Can deploy different branches, tags, or any SHA1 easily.
+      #   * Supports prompting for password / passphrase upon checkout.
+      #     (I am amazed at how some plugins don't do this)
+      #   * Supports :scm_command, :scm_password, :scm_passphrase Capistrano
+      #     directives.
+      #
+      # REQUIREMENTS
+      # ------------
+      #
+      # Git is required to be installed on your remote machine(s), because a
+      # clone and checkout is done to get the code up there.  This is the way
+      # I prefer to deploy; there is no alternative to this, so :deploy_via
+      # is ignored.
+      #
+      # CONFIGURATION
+      # -------------
+      #
+      # Use this plugin by adding the following line in your config/deploy.rb:
+      #
+      #   set :scm, :git
+      #
+      # Set <tt>:repository</tt> to the path of your Git repo:
+      #
+      #   set :repository, "someuser@somehost:/home/myproject"
+      #
+      # The above two options are required to be set, the ones below are
+      # optional.
+      #
+      # You may set <tt>:branch</tt>, which is the reference to the branch, tag,
+      # or any SHA1 you are deploying, for example:
+      #
+      #   set :branch, "origin/master"
+      #
+      # Otherwise, HEAD is assumed.  I strongly suggest you set this.  HEAD is
+      # not always the best assumption.
+      #
+      # The <tt>:scm_command</tt> configuration variable, if specified, will
+      # be used as the full path to the git executable on the *remote* machine:
+      #
+      #   set :scm_command, "/opt/local/bin/git"
+      #
+      # For compatibility with deploy scripts that may have used the 1.x
+      # version of this plugin before upgrading, <tt>:git</tt> is still
+      # recognized as an alias for :scm_command.
+      #
+      # Set <tt>:scm_password</tt> to the password needed to clone your repo
+      # if you don't have password-less (public key) entry:
+      #
+      #   set :scm_password, "my_secret'
+      #
+      # Otherwise, you will be prompted for a password.
+      #
+      # <tt>:scm_passphrase</tt> is also supported.
+      #
+      # The remote cache strategy is also supported.
+      #
+      #   set :repository_cache, "git_master"
+      #   set :deploy_via, :remote_cache
+      #
+      # For faster clone, you can also use shallow cloning.  This will set the
+      # '--depth' flag using the depth specified.  This *cannot* be used 
+      # together with the :remote_cache strategy
+      #
+      #   set :git_shallow_clone, 1
+      #
+      # AUTHORS
+      # -------
+      #
+      # Garry Dolley http://scie.nti.st
+      # Contributions by Geoffrey Grosenbach http://topfunky.com
+      #              and Scott Chacon http://jointheconversation.org
+      
+      class Git < Base
+        # Sets the default command name for this SCM on your *local* machine.
+        # Users may override this by setting the :scm_command variable.
+        default_command "git"
+
+        # When referencing "head", use the branch we want to deploy or, by
+        # default, Git's reference of HEAD (the latest changeset in the default
+        # branch, usually called "master").
+        def head
+          configuration[:branch] || 'HEAD'
+        end
+
+        # Performs a clone on the remote machine, then checkout on the branch
+        # you want to deploy.
+        def checkout(revision, destination)
+          git      = command
+
+          branch   = head
+
+          fail "No branch specified, use for example 'set :branch, \"origin/master\"' in your deploy.rb" unless branch
+
+          if depth = configuration[:git_shallow_clone]
+            execute  = "#{git} clone --depth #{depth} #{configuration[:repository]} #{destination} && "
+          else
+            execute  = "#{git} clone #{configuration[:repository]} #{destination} && "
+          end
+
+          execute += "cd #{destination} && #{git} checkout -b deploy #{branch}" 
+
+          execute
+        end
+
+        # Merges the changes to 'head' since the last fetch, for remote_cache
+        # deployment strategy
+        def sync(revision, destination)
+          execute = "cd #{destination} && git fetch origin && "
+
+          if head == 'HEAD'
+            execute += "git merge origin/HEAD"
+          else
+            execute += "git merge #{head}"
+          end
+
+          execute
+        end
+
+        # Returns a string of diffs between two revisions
+        def diff(from, to=nil)
+          from << "..#{to}" if to
+          scm :diff, from
+        end
+
+        # Returns a log of changes between the two revisions (inclusive).
+        def log(from, to=nil)
+          from << "..#{to}" if to
+          scm :log, from
+        end
+
+        # Getting the actual commit id, in case we were passed a tag
+        # or partial sha or something - it will return the sha if you pass a sha, too
+        def query_revision(revision)
+          yield(scm('rev-parse', revision)).chomp
+        end
+
+        def command
+          # For backwards compatibility with 1.x version of this module
+          configuration[:git] || super
+        end
+
+        # Determines what the response should be for a particular bit of text
+        # from the SCM. Password prompts, connection requests, passphrases,
+        # etc. are handled here.
+        def handle_data(state, stream, text)
+          logger.info "[#{stream}] #{text}"
+          case text
+          when /\bpassword.*:/i
+            # git is prompting for a password
+            unless pass = configuration[:scm_password]
+              pass = Capistrano::CLI.password_prompt
+            end
+            "#{pass}\n"
+          when %r{\(yes/no\)}
+            # git is asking whether or not to connect
+            "yes\n"
+          when /passphrase/i
+            # git is asking for the passphrase for the user's key
+            unless pass = configuration[:scm_passphrase]
+              pass = Capistrano::CLI.password_prompt
+            end
+            "#{pass}\n"
+          when /accept \(t\)emporarily/
+            # git is asking whether to accept the certificate
+            "t\n"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -52,8 +52,16 @@ module Capistrano
         # executed (svn info), and will extract the revision from the response.
         def query_revision(revision)
           return revision if revision =~ /^\d+$/
-          result = yield(scm(:info, repository, authentication, "-r#{revision}"))
-          YAML.load(result)['Revision']
+          command = scm(:info, repository, authentication, "-r#{revision}")
+          result = yield(command)
+          yaml = YAML.load(result)
+          raise "tried to run `#{command}' and got unexpected result #{result.inspect}" unless Hash === yaml
+          yaml['Last Changed Rev'] || yaml['Revision']
+        end
+
+        # Increments the given revision number and returns it.
+        def next_revision(revision)
+          revision.to_i + 1
         end
 
         # Determines what the response should be for a particular bit of text
@@ -81,14 +89,17 @@ module Capistrano
 
         private
 
-          # If a username or password is configured for the SCM, return the
-          # command-line switches for those values.
+          # If a username is configured for the SCM, return the command-line
+          # switches for that. Note that we don't need to return the password
+          # switch, since Capistrano will check for that prompt in the output
+          # and will respond appropriately.
           def authentication
-            auth = ""
-            auth << "--username #{variable(:scm_username)} " if variable(:scm_username)
-            auth << "--password #{variable(:scm_password)} " if variable(:scm_password)
-            auth << "--no-auth-cache" if !auth.empty?
-            auth
+            username = variable(:scm_username)
+            return "" unless username
+            result = "--username #{variable(:scm_username)} "
+            result << "--password #{variable(:scm_password)} " unless variable(:scm_prefer_prompt)
+            result << "--no-auth-cache " unless variable(:scm_auth_cache)
+            result
           end
 
           # If verbose output is requested, return nil, otherwise return the

data/lib/capistrano/recipes/deploy/strategy/copy.rb

@@ -32,7 +32,8 @@ module Capistrano
           logger.trace "compressing #{destination} to #{filename}"
           Dir.chdir(tmpdir) { system(compress(File.basename(destination), File.basename(filename)).join(" ")) }
 
-          put File.read(filename), remote_filename
+          content = File.open(filename, "rb") { |f| f.read }
+          put content, remote_filename 
           run "cd #{configuration[:releases_path]} && #{decompress(remote_filename).join(" ")} && rm #{remote_filename}"
         ensure
           FileUtils.rm filename rescue nil

data/lib/capistrano/recipes/upgrade.rb

@@ -10,7 +10,7 @@ namespace :upgrade do
     tag file used in Capistrano 2.x. It is non-destructive and may be safely \
     run any number of times.
   DESC
-  task :revisions do
+  task :revisions, :except => { :no_release => true } do
     revisions = capture("cat #{deploy_to}/revisions.log")
 
     mapping = {}

data/lib/capistrano/shell.rb

@@ -166,24 +166,12 @@ HELP
 
       # Execute a command on the given list of servers.
       def exec_command(command, servers)
-        processor = Proc.new do |ch, stream, out|
-          # TODO: more robust prompt detection
-          out.each do |line|
-            if stream == :out
-              if out =~ /Password:\s*/i
-                ch.send_data "#{configuration[:password]}\n"
-              else
-                puts "[#{ch[:server]}] #{line.chomp}"
-              end
-            elsif stream == :err
-              puts "[#{ch[:server]} ERR] #{line.chomp}"
-            end
-          end
-        end
-
-        previous = trap("INT") { cmd.stop! }
+        command = command.gsub(/\bsudo\b/, "sudo -p '#{configuration.sudo_prompt}'")
+        processor = configuration.sudo_behavior_callback(Configuration.default_io_proc)
         sessions = servers.map { |server| configuration.sessions[server] }
-        Command.process(command, sessions, :logger => configuration.logger, &Capistrano::Configuration.default_io_proc)
+        cmd = Command.new(command, sessions, :logger => configuration.logger, &processor)
+        previous = trap("INT") { cmd.stop! }
+        cmd.process!
       rescue Capistrano::Error => error
         warn "error: #{error.message}"
       ensure

data/lib/capistrano/upload.rb

@@ -101,7 +101,7 @@ module Capistrano
           sftp.channel[:failed] = false
 
           real_filename = filename.gsub(/\$CAPISTRANO:HOST\$/, server.host)
-          sftp.open(real_filename, IO::WRONLY | IO::CREAT | IO::TRUNC, options[:mode] || 0660) do |status, handle|
+          sftp.open(real_filename, IO::WRONLY | IO::CREAT | IO::TRUNC, options[:mode] || 0664) do |status, handle|
             break unless check_status(sftp, "open #{real_filename}", server, status)
             
             logger.info "uploading data to #{server}:#{real_filename}" if logger

data/lib/capistrano/version.rb

@@ -11,7 +11,7 @@ module Capistrano
     end
 
     MAJOR = 2
-    MINOR = 0
+    MINOR = 1
     TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join(".")

data/test/command_test.rb

@@ -19,43 +19,52 @@ class CommandTest < Test::Unit::TestCase
     assert_equal "ls\\\necho", cmd.command
   end
 
-  def test_command_with_env_key_should_have_environment_constructed_and_prepended
+  def test_command_with_pty_should_request_pty_and_register_success_callback
     session = setup_for_extracting_channel_action(:on_success) do |ch|
+      ch.expects(:request_pty).with(:want_reply => true)
+      ch.expects(:exec).with(%(sh -c "ls"))
+    end
+    Capistrano::Command.new("ls", [session], :pty => true)
+  end
+
+  def test_command_with_env_key_should_have_environment_constructed_and_prepended
+    session = setup_for_extracting_channel_action do |ch|
+      ch.expects(:request_pty).never
       ch.expects(:exec).with(%(env FOO=bar sh -c "ls"))
     end
     Capistrano::Command.new("ls", [session], :env => { "FOO" => "bar" })
   end
 
   def test_env_with_symbolic_key_should_be_accepted_as_a_string
-    session = setup_for_extracting_channel_action(:on_success) do |ch|
+    session = setup_for_extracting_channel_action do |ch|
       ch.expects(:exec).with(%(env FOO=bar sh -c "ls"))
     end
     Capistrano::Command.new("ls", [session], :env => { :FOO => "bar" })
   end
 
   def test_env_as_string_should_be_substituted_in_directly
-    session = setup_for_extracting_channel_action(:on_success) do |ch|
+    session = setup_for_extracting_channel_action do |ch|
       ch.expects(:exec).with(%(env HOWDY=there sh -c "ls"))
     end
     Capistrano::Command.new("ls", [session], :env => "HOWDY=there")
   end
 
   def test_env_with_symbolic_value_should_be_accepted_as_string
-    session = setup_for_extracting_channel_action(:on_success) do |ch|
+    session = setup_for_extracting_channel_action do |ch|
       ch.expects(:exec).with(%(env FOO=bar sh -c "ls"))
     end
     Capistrano::Command.new("ls", [session], :env => { "FOO" => :bar })
   end
 
   def test_env_value_should_be_escaped
-    session = setup_for_extracting_channel_action(:on_success) do |ch|
+    session = setup_for_extracting_channel_action do |ch|
       ch.expects(:exec).with(%(env FOO=(\\ \\\"bar\\\"\\ ) sh -c "ls"))
     end
     Capistrano::Command.new("ls", [session], :env => { "FOO" => '( "bar" )' })
   end
 
   def test_env_with_multiple_keys_should_chain_the_entries_together
-    session = setup_for_extracting_channel_action(:on_success) do |ch|
+    session = setup_for_extracting_channel_action do |ch|
       ch.expects(:exec).with do |command|
         command =~ /^env / &&
         command =~ /\ba=b\b/ &&
@@ -73,6 +82,7 @@ class CommandTest < Test::Unit::TestCase
 
     session.expects(:open_channel).yields(channel)
     channel.expects(:[]=).with(:host, "capistrano")
+    channel.stubs(:[]).with(:host).returns("capistrano")
 
     Capistrano::Command.new("ls", [session])
   end
@@ -83,47 +93,45 @@ class CommandTest < Test::Unit::TestCase
 
     session.expects(:open_channel).yields(channel)
     channel.expects(:[]=).with(:options, {:data => "here we go"})
+    channel.stubs(:[]).with(:host).returns("capistrano")
 
     Capistrano::Command.new("ls", [session], :data => "here we go")
   end
 
-  def test_open_channel_should_request_pty
-    session = mock(:xserver => server("capistrano"))
-    channel = stub_everything
-
-    session.expects(:open_channel).yields(channel)
-    channel.expects(:request_pty).with(:want_reply => true)
-
-    Capistrano::Command.new("ls", [session])
-  end
-
   def test_successful_channel_should_send_command
-    session = setup_for_extracting_channel_action(:on_success) do |ch|
+    session = setup_for_extracting_channel_action do |ch|
       ch.expects(:exec).with(%(sh -c "ls"))
     end
     Capistrano::Command.new("ls", [session])
   end
 
   def test_successful_channel_with_shell_option_should_send_command_via_specified_shell
-    session = setup_for_extracting_channel_action(:on_success) do |ch|
+    session = setup_for_extracting_channel_action do |ch|
       ch.expects(:exec).with(%(/bin/bash -c "ls"))
     end
     Capistrano::Command.new("ls", [session], :shell => "/bin/bash")
   end
 
+  def test_successful_channel_with_shell_false_should_send_command_without_shell
+    session = setup_for_extracting_channel_action do |ch|
+      ch.expects(:exec).with(%(echo `hostname`))
+    end
+    Capistrano::Command.new("echo `hostname`", [session], :shell => false)
+  end
+
   def test_successful_channel_should_send_data_if_data_key_is_present
-    session = setup_for_extracting_channel_action(:on_success) do |ch|
+    session = setup_for_extracting_channel_action do |ch|
       ch.expects(:exec).with(%(sh -c "ls"))
       ch.expects(:send_data).with("here we go")
     end
     Capistrano::Command.new("ls", [session], :data => "here we go")
   end
 
-  def test_unsuccessful_channel_should_close_channel
+  def test_unsuccessful_pty_request_should_close_channel
     session = setup_for_extracting_channel_action(:on_failure) do |ch|
       ch.expects(:close)
     end
-    Capistrano::Command.new("ls", [session])
+    Capistrano::Command.new("ls", [session], :pty => true)
   end
 
   def test_on_data_should_invoke_callback_as_stdout
@@ -258,14 +266,14 @@ class CommandTest < Test::Unit::TestCase
   end
 
   def test_process_with_host_placeholder_should_substitute_placeholder_with_each_host
-    session = setup_for_extracting_channel_action(:on_success) do |ch|
+    session = setup_for_extracting_channel_action do |ch|
       ch.expects(:exec).with(%(sh -c "echo capistrano"))
     end
     Capistrano::Command.new("echo $CAPISTRANO:HOST$", [session])
   end
 
   def test_process_with_unknown_placeholder_should_not_replace_placeholder
-    session = setup_for_extracting_channel_action(:on_success) do |ch|
+    session = setup_for_extracting_channel_action do |ch|
       ch.expects(:exec).with(%(sh -c "echo \\$CAPISTRANO:OTHER\\$"))
     end
     Capistrano::Command.new("echo $CAPISTRANO:OTHER$", [session])
@@ -283,19 +291,18 @@ class CommandTest < Test::Unit::TestCase
       ch
     end
 
-    def setup_for_extracting_channel_action(action, *args)
+    def setup_for_extracting_channel_action(action=nil, *args)
       s = server("capistrano")
       session = mock("session", :xserver => s)
 
       channel = stub_everything
       session.expects(:open_channel).yields(channel)
 
-      ch = mock
-      ch.stubs(:[]).with(:server).returns(s)
-      ch.stubs(:[]).with(:host).returns(s.host)
-      channel.expects(action).yields(ch, *args)
+      channel.stubs(:[]).with(:server).returns(s)
+      channel.stubs(:[]).with(:host).returns(s.host)
+      channel.expects(action).yields(channel, *args) if action
 
-      yield ch if block_given?
+      yield channel if block_given?
 
       session
     end