capistrano 1.1.0 → 1.2.0

data/lib/capistrano/cli.rb

@@ -110,6 +110,11 @@ module Capistrano
           "be specified, and are loaded in the given order."
         ) { |value| @options[:actions] << value }
 
+        opts.on("-f", "--file FILE",
+          "A recipe file to load. Multiple recipes may",
+          "be specified, and are loaded in the given order."
+        ) { |value| @options[:recipes] << value }
+
         opts.on("-p", "--password [PASSWORD]",
           "The password to use when connecting. If the switch",
           "is given without a password, the password will be",
@@ -119,8 +124,12 @@ module Capistrano
 
         opts.on("-r", "--recipe RECIPE",
           "A recipe file to load. Multiple recipes may",
-          "be specified, and are loaded in the given order."
-        ) { |value| @options[:recipes] << value }
+          "be specified, and are loaded in the given order.",
+          "(This option is deprecated--please use -f instead)"
+        ) do |value|
+          warn "Deprecated -r/--recipe flag used. Please use -f instead"
+          @options[:recipes] << value
+        end
 
         opts.on("-s", "--set NAME=VALUE",
           "Specify a variable and it's value to set. This",
@@ -188,13 +197,14 @@ You can use the --apply-to switch to generate a minimal set of capistrano
 scripts and recipes for an application. Just specify the path to the application
 as the argument to --apply-to, like this:
 
-  capistrano --apply-to ~/projects/myapp
+  cap --apply-to ~/projects/myapp
 
-You'll wind up with a sample deployment recipe in config/deploy.rb, some new
-rake tasks in config/tasks, and a capistrano script in your script directory.
+You'll wind up with a sample deployment recipe in config/deploy.rb and some new
+rake tasks in config/tasks.
 
 (Currently, --apply-to only works with Rails applications.)
 DETAIL
+#' # vim syntax highlighting fix
 
         if args.empty?
           puts opts
@@ -217,10 +227,10 @@ DETAIL
 
     # Beginning running Capistrano based on the configured options.
     def execute!
-      if !@options[:recipes].empty?
-        execute_recipes!
-      elsif @options[:apply_to]
+      if @options[:apply_to]
         execute_apply_to!
+      else
+        execute_recipes!
       end
     end
 
@@ -271,7 +281,6 @@ DETAIL
         elsif !apply_to_given
           look_for_default_recipe_file! if @options[:recipes].empty?
           look_for_raw_actions!
-          abort "You must specify at least one recipe" if @options[:recipes].empty?
           abort "You must specify at least one action" if @options[:actions].empty?
         else
           @options[:application] = args.shift

data/lib/capistrano/command.rb

@@ -48,6 +48,14 @@ module Capistrano
       self
     end
 
+    # Force the command to stop processing, by closing all open channels
+    # associated with this command.
+    def stop!
+      @channels.each do |ch|
+        ch.close unless ch[:closed]
+      end
+    end
+
     private
 
       def open_channels

data/lib/capistrano/configuration.rb

@@ -150,7 +150,7 @@ module Capistrano
         instance_eval(options[:string], options[:name] || "<eval>")
 
       elsif options[:proc]
-        logger.trace "loading configuration #{options[:proc].inspect}"
+        logger.trace "loading configuration #{eval("__FILE__", options[:proc])}"
         instance_eval(&options[:proc])
 
       else

data/lib/capistrano/gateway.rb

@@ -31,28 +31,23 @@ module Capistrano
     def initialize(server, config) #:nodoc:
       @config = config
       @pending_forward_requests = {}
-      @mutex = Mutex.new
       @next_port = MAX_PORT
       @terminate_thread = false
+      @port_guard = Mutex.new
 
+      mutex = Mutex.new
       waiter = ConditionVariable.new
 
       @thread = Thread.new do
         @config.logger.trace "starting connection to gateway #{server}"
         SSH.connect(server, @config) do |@session|
           @config.logger.trace "gateway connection established"
-          @mutex.synchronize { waiter.signal }
-          connection = @session.registry[:connection][:driver]
-          loop do
-            break if @terminate_thread
-            sleep 0.1 unless connection.reader_ready?
-            connection.process true
-            Thread.new { process_next_pending_connection_request }
-          end
+          mutex.synchronize { waiter.signal }
+          @session.loop { !@terminate_thread }
         end
       end
 
-      @mutex.synchronize { waiter.wait(@mutex) }
+      mutex.synchronize { waiter.wait(mutex) }
     end
 
     # Shuts down all forwarded connections and terminates the gateway.
@@ -73,45 +68,36 @@ module Capistrano
     # host to the server, via the gateway, and then opens and returns a new
     # Net::SSH connection via that port.
     def connect_to(server)
-      @mutex.synchronize do
-        @pending_forward_requests[server] = ConditionVariable.new
-        @pending_forward_requests[server].wait(@mutex)
-        @pending_forward_requests.delete(server)
+      connection = nil
+      @config.logger.trace "establishing connection to #{server} via gateway"
+      port = next_port
+
+      thread = Thread.new do
+        begin
+          @session.forward.local(port, server, 22)
+          connection = SSH.connect('127.0.0.1', @config, port)
+          @config.logger.trace "connection to #{server} via gateway established"
+        rescue Errno::EADDRINUSE
+          port = next_port
+          retry
+        rescue Exception => e
+          puts e.class.name
+          puts e.backtrace.join("\n")
+        end
       end
+
+      thread.join
+      connection or raise "Could not establish connection to #{server}"
     end
 
     private
 
       def next_port
-        port = @next_port
-        @next_port -= 1
-        @next_port = MAX_PORT if @next_port < MIN_PORT
-        port
-      end
-
-      def process_next_pending_connection_request
-        @mutex.synchronize do
-          key = @pending_forward_requests.keys.detect { |k| ConditionVariable === @pending_forward_requests[k] } or return
-          var = @pending_forward_requests[key]
-
-          @config.logger.trace "establishing connection to #{key} via gateway"
-
-          port = next_port
-
-          begin
-            @session.forward.local(port, key, 22)
-            @pending_forward_requests[key] = SSH.connect('127.0.0.1', @config,
-              port)
-            @config.logger.trace "connection to #{key} via gateway established"
-          rescue Errno::EADDRINUSE
-            port = next_port
-            retry
-          rescue Object
-            @pending_forward_requests[key] = nil
-            raise
-          ensure
-            var.signal
-          end
+        @port_guard.synchronize do
+          port = @next_port
+          @next_port -= 1
+          @next_port = MAX_PORT if @next_port < MIN_PORT
+          port
         end
       end
   end

data/lib/capistrano/recipes/standard.rb

@@ -35,10 +35,11 @@ task :show_tasks do
 end
 
 desc "Set up the expected application directory structure on all boxes"
-task :setup, :roles => [:app, :db, :web] do
+task :setup, :except => { :no_release => true } do
   run <<-CMD
     mkdir -p -m 775 #{releases_path} #{shared_path}/system &&
-    mkdir -p -m 777 #{shared_path}/log
+    mkdir -p -m 777 #{shared_path}/log &&
+    mkdir -p -m 777 #{shared_path}/pids
   CMD
 end
 
@@ -64,7 +65,7 @@ desc <<-DESC
 Update all servers with the latest release of the source code. All this does
 is do a checkout (as defined by the selected scm module).
 DESC
-task :update_code, :roles => [:app, :db, :web] do
+task :update_code, :except => { :no_release => true } do
   on_rollback { delete release_path, :recursive => true }
 
   source.checkout(self)
@@ -74,13 +75,23 @@ task :update_code, :roles => [:app, :db, :web] do
     ln -nfs #{shared_path}/log #{release_path}/log &&
     ln -nfs #{shared_path}/system #{release_path}/public/system
   CMD
+  
+  run <<-CMD
+    test -d #{shared_path}/pids && 
+    rm -rf #{release_path}/tmp/pids && 
+    ln -nfs #{shared_path}/pids #{release_path}/tmp/pids; true
+  CMD
+
+  # uncache the list of releases, so that the next time it is called it will
+  # include the newly released path.
+  @releases = nil
 end
 
 desc <<-DESC
 Rollback the latest checked-out version to the previous one by fixing the
 symlinks and deleting the current release from all servers.
 DESC
-task :rollback_code, :roles => [:app, :db, :web] do
+task :rollback_code, :except => { :no_release => true } do
   if releases.length < 2
     raise "could not rollback the code because there is no prior release"
   else
@@ -95,7 +106,7 @@ desc <<-DESC
 Update the 'current' symlink to point to the latest version of
 the application's code.
 DESC
-task :symlink, :roles => [:app, :db, :web] do
+task :symlink, :except => { :no_release => true } do
   on_rollback { run "ln -nfs #{previous_release} #{current_path}" }
   run "ln -nfs #{current_release} #{current_path}"
 end
@@ -109,6 +120,16 @@ task :restart, :roles => :app do
   send(run_method, "#{current_path}/script/process/reaper")
 end
 
+desc <<-DESC
+Updates the code and fixes the symlink under a transaction
+DESC
+task :update do
+  transaction do
+    update_code
+    symlink
+  end
+end
+
 desc <<-DESC
 Run the migrate rake task. By default, it runs this in the version of the app
 indicated by the 'current' symlink. (This means you should not invoke this task
@@ -137,11 +158,7 @@ A macro-task that updates the code, fixes the symlink, and restarts the
 application servers.
 DESC
 task :deploy do
-  transaction do
-    update_code
-    symlink
-  end
-
+  update
   restart
 end
 
@@ -240,3 +257,14 @@ task :invoke, :roles => Capistrano.str2roles(ENV["ROLES"] || "") do
   method = ENV["SUDO"] ? :sudo : :run
   send(method, ENV["COMMAND"])
 end
+
+desc <<-DESC
+Begin an interactive Capistrano session. This gives you an interactive
+terminal from which to execute tasks and commands on all of your servers.
+(This is still an experimental feature, and is subject to change without
+notice!)
+DESC
+task(:shell) do
+  require 'capistrano/shell'
+  Capistrano::Shell.run!(self)
+end

data/lib/capistrano/scm/base.rb

@@ -28,7 +28,6 @@ module Capistrano
       private
 
         def run_checkout(actor, guts, &block)
-          log = "#{configuration.deploy_to}/revisions.log"
           directory = File.basename(configuration.release_path)
 
           command = <<-STR
@@ -53,7 +52,7 @@ module Capistrano
         def logging_commands(directory = nil)
           log = "#{configuration.deploy_to}/revisions.log"
 
-          "(test -e #{log} || touch #{log} && chmod 666 #{log}) && " +
+          "(test -e #{log} || (touch #{log} && chmod 666 #{log})) && " +
           "echo `date +\"%Y-%m-%d %H:%M:%S\"` $USER #{configuration.revision} #{directory} >> #{log};"
         end
     end

data/lib/capistrano/scm/cvs.rb

@@ -33,6 +33,11 @@ module Capistrano
     class Cvs < Base
       def initialize(configuration)
         super(configuration)
+
+        if not @configuration.respond_to?(:local) then
+          @configuration.set(:local,".") 
+        end
+
         if not configuration.respond_to?(:branch) then
           configuration.set(:branch) { self.current_branch }
         else

data/lib/capistrano/scm/mercurial.rb

@@ -0,0 +1,83 @@
+require 'capistrano/scm/base'
+
+module Capistrano
+  module SCM
+
+    # An SCM module for using Mercurial as your source control tool.
+    # You can use it by placing the following line in your configuration:
+    #
+    #   set :scm, :mercurial
+    #
+    # Also, this module accepts a <tt>:mercurial</tt> configuration variable,
+    # which (if specified) will be used as the full path to the hg
+    # executable on the remote machine:
+    #
+    #   set :mercurial, "/usr/local/bin/hg"
+    class Mercurial < Base
+      # Return a string identifying the tip changeset in the mercurial
+      # repository. Note that this fetches the tip changeset from the
+      # local repository, but capistrano will deploy from your _remote_
+      # repository. So just make sure your local repository is synchronized
+      # with your remote one.
+      def latest_revision
+        `#{mercurial} tip --template '{node|short}'`
+      end
+
+      # Return the changeset currently deployed.
+      def current_revision(actor)
+        # NOTE:
+        # copied almost verbatim from svn except its not cast into an int
+        # this should be the same for almost _every_ scm can we take it out
+        # of SCM-specific code?
+        latest = actor.releases.last
+        grep = %(grep " #{latest}$" #{configuration.deploy_to}/revisions.log)
+        result = ""
+        actor.run(grep, :once => true) do |ch, str, out|
+          result << out if str == :out
+          raise "could not determine current changeset" if str == :err
+        end
+
+        date, time, user, changeset, dir = result.split
+        raise "current changeset not found in revisions.log" unless dir == latest
+        changeset
+      end
+
+      # Return a string containing the diff between the two changesets. +from+
+      # and +to+ may be in any format that mercurial recognizes as a valid 
+      # changeset. If +from+ is +nil+, it defaults to the last deployed
+      # changeset. If +to+ is +nil+, it defaults to the current working
+      # directory.
+      def diff(actor, from = current_revision(actor), to = nil)
+        cmd = "#{mercurial} diff -r #{from}"
+        cmd << " -r #{to}" if to
+        `#{cmd}`
+      end
+
+      # Check out (on all servers associated with the current task) the latest
+      # revision. Uses the given actor instance to execute the command. If
+      # mercurial asks for a password this will automatically provide it
+      # (assuming the requested password is the same as the password for
+      # logging into the remote server.) If ssh repository method is used,
+      # authorized keys must be setup.
+      def checkout(actor)
+        command = "#{mercurial} clone -U #{configuration.repository} " +
+                  "#{actor.release_path} && " +
+                  "#{mercurial} -R #{actor.release_path} update " +
+                   "-C #{configuration.revision} &&"
+        run_checkout(actor, command, &hg_stream_handler(actor)) 
+      end
+
+      private
+      def mercurial
+        configuration[:mercurial] || "hg"
+      end
+
+      def hg_stream_handler(actor)
+        Proc.new do |ch, stream, out|
+          prefix = "#{stream} :: #{ch[:host]}"
+          actor.logger.info out, prefix
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/scm/subversion.rb

@@ -16,22 +16,14 @@ module Capistrano
     #   set :svn, "/opt/local/bin/svn"
     class Subversion < Base
       # Return an integer identifying the last known revision in the svn
-      # repository. (This integer is currently the revision number.) If latest
-      # revision does not exist in the given repository, this routine will
-      # walk up the directory tree until it finds it.
+      # repository. (This integer is currently the revision number.)
       def latest_revision
-        configuration.logger.debug "querying latest revision..." unless @latest_revision
-        repo = configuration.repository
-        until @latest_revision
-          match = svn_log(repo).scan(/r(\d+)/).first
-          @latest_revision = match ? match.first : nil
-          if @latest_revision.nil?
-            # if a revision number was not reported, move up a level in the path
-            # and try again.
-            repo = File.dirname(repo)
+        @latest_revision ||= begin
+            configuration.logger.debug "querying latest revision..."
+            match = svn_log(configuration.repository).scan(/r(\d+)/).first or
+              raise "Could not determine latest revision"
+            match.first
           end
-        end
-        @latest_revision
       end
 
       # Return the number of the revision currently deployed.
@@ -87,13 +79,17 @@ module Capistrano
         end
 
         def svn_log(path)
-          `svn log -q -rhead #{path}`
+          `svn log -q --limit 1 #{path}`
         end
 
         def svn_password
           configuration[:svn_password] || configuration[:password]
         end
 
+        def svn_passphrase
+          configuration[:svn_passphrase] || svn_password
+        end
+        
         def svn_stream_handler(actor)
           Proc.new do |ch, stream, out|
             prefix = "#{stream} :: #{ch[:host]}"
@@ -105,14 +101,18 @@ module Capistrano
               actor.logger.info "subversion is asking whether to connect or not",
                 prefix
               ch.send_data "yes\n"
-            elsif out =~ %r{passphrase}
-              message = "subversion needs your key's passphrase, sending empty string"
+            elsif out =~ %r{passphrase}i
+              message = "subversion needs your key's passphrase"
               actor.logger.info message, prefix
-              ch.send_data "\n"
+              ch.send_data "#{svn_passphrase}\n"
             elsif out =~ %r{The entry \'(\w+)\' is no longer a directory}
               message = "subversion can't update because directory '#{$1}' was replaced. Please add it to svn:ignore."
               actor.logger.info message, prefix
               raise message
+            elsif out =~ %r{accept \(t\)emporarily}
+              message = "accepting certificate temporarily"
+              actor.logger.info message, prefix
+              ch.send_data "t\n"
             end
           end
         end