capistrano 2.0.0 → 2.1.0

data/CHANGELOG

@@ -1,3 +1,57 @@
+*2.1.0* October 14, 2007
+
+* Default to 0664 instead of 0660 on upload [Jamis Buck]
+
+* Fix deploy:pending to query SCM for the subsequent revision so that it does not include the last deployed change [Jamis Buck]
+
+* Prefer 'Last Changed Rev' over 'Revision' when querying latest revision via Subversion [Jamis Buck]
+
+* Explicitly require 'stringio' in copy_test [mislav]
+
+* When Subversion#query_revision fails, give a more sane error [Jamis Buck]
+
+* Don't run the upgrade:revisions task on non-release servers [Jamis Buck]
+
+* Fix cap shell to properly recognize sudo prompt [Mark Imbriaco, barnaby, Jamis Buck]
+
+* Git SCM module [Garry Dolley, Geoffrey Grosenbach, Scott Chacon]
+
+* Use the --password switch for subversion by default, but add :scm_prefer_prompt variable (defaults to false) [Jamis Buck]
+
+
+*2.0.100 (2.1 Preview 1)* September 1, 2007
+
+* capify-generated Capfile will autoload all recipes from vendor/plugins/*/recipes/*.rb [Graeme Mathieson]
+
+* Use sudo -p switch to set sudo password prompt to something predictable [Mike Bailey]
+
+* Allow independent configurations to require the same recipe file [Jamis Buck]
+
+* Set :shell to false to run a command without wrapping it in "sh -c" [Jamis Buck]
+
+* Don't request a pty by default [Jamis Buck]
+
+* Add a "match" remote dependency method [Adam Greene]
+
+* Allow auth-caching of subversion credentials to be enabled via :scm_auth_cache [tsmith]
+
+* Don't let a task trigger itself when used as the source for an "on" hook [Jamis Buck]
+
+* Avoid using the --password switch with subversion for security purposes [sentinel]
+
+* Add version_dir, current_dir, and shared_dir variables for naming the directories used in deployment [drinkingbird]
+
+* Use Windows-safe binary reads for reading file contents [Ladislav Martincik]
+
+* Add Accurev SCM support [Doug Barth]
+
+* Use the :runner variable to determine who to sudo as for deploy:restart [Graham Ashton]
+
+* Add Namespaces#top to always return a reference to the topmost namespace [Jamis Buck]
+
+* Change the "-h" output so that it does not say that "-q" is the default [Jamis Buck]
+
+
 *2.0.0* July 21, 2007
 
 * Make the "no matching servers" error more sane [halorgium]

data/bin/capify

@@ -37,6 +37,7 @@ end
 files = {
   "Capfile" => unindent(<<-FILE),
     load 'deploy' if respond_to?(:namespace) # cap2 differentiator
+    Dir['vendor/plugins/*/recipes/*.rb'].each { |plugin| load(plugin) }
     load 'config/deploy'
   FILE
 

data/lib/capistrano/callback.rb

@@ -37,5 +37,9 @@ module Capistrano
     def call
       config.find_and_execute_task(source)
     end
+
+    def applies_to?(task)
+      super && (task.nil? || task.fully_qualified_name != source.to_s)
+    end
   end
 end

data/lib/capistrano/cli/options.rb

@@ -54,7 +54,7 @@ module Capistrano
           ) { options[:password] = nil }
 
           opts.on("-q", "--quiet",
-            "Make the output as quiet as possible (default)"
+            "Make the output as quiet as possible."
           ) { options[:verbose] = 0 }
 
           opts.on("-S", "--set-before NAME=VALUE",
@@ -180,4 +180,4 @@ module Capistrano
 
     end
   end
-end
+end

data/lib/capistrano/command.rb

@@ -83,24 +83,39 @@ module Capistrano
             channel[:server] = server
             channel[:host] = server.host
             channel[:options] = options
-            channel.request_pty :want_reply => true
 
-            channel.on_success do |ch|
+            execute_command = Proc.new do |ch|
               logger.trace "executing command", ch[:server] if logger
-              escaped = replace_placeholders(command, ch).gsub(/[$\\`"]/) { |m| "\\#{m}" }
-              command_line = [environment, options[:shell] || "sh", "-c", "\"#{escaped}\""].compact.join(" ")
+              cmd = replace_placeholders(command, ch)
+
+              if options[:shell] == false
+                shell = nil
+              else
+                shell = "#{options[:shell] || "sh"} -c"
+                cmd = cmd.gsub(/[$\\`"]/) { |m| "\\#{m}" }
+                cmd = "\"#{cmd}\""
+              end
+
+              command_line = [environment, shell, cmd].compact.join(" ")
+
               ch.exec(command_line)
               ch.send_data(options[:data]) if options[:data]
             end
 
-            channel.on_failure do |ch|
-              # just log it, don't actually raise an exception, since the
-              # process method will see that the status is not zero and will
-              # raise an exception then.
-              logger.important "could not open channel", ch[:server] if logger
-              ch.close
+            if options[:pty]
+              channel.request_pty(:want_reply => true)
+              channel.on_success(&execute_command)
+              channel.on_failure do |ch|
+                # just log it, don't actually raise an exception, since the
+                # process method will see that the status is not zero and will
+                # raise an exception then.
+                logger.important "could not open channel", ch[:server] if logger
+                ch.close
+              end
+            else
+              execute_command.call(channel)
             end
-
+              
             channel.on_data do |ch, data|
               @callback[ch, :out, data] if @callback
             end

data/lib/capistrano/configuration/actions/invocation.rb

@@ -23,6 +23,7 @@ module Capistrano
         def initialize_with_invocation(*args) #:nodoc:
           initialize_without_invocation(*args)
           set :default_environment, {}
+          set :default_run_options, {}
         end
 
         # Invokes the given command. If a +via+ key is given, it will be used
@@ -69,7 +70,7 @@ module Capistrano
           as = options.delete(:as)
 
           user = as && "-u #{as}"
-          command = [fetch(:sudo, "sudo"), user, command].compact.join(" ")
+          command = [fetch(:sudo, "sudo"), "-p '#{sudo_prompt}'", user, command].compact.join(" ")
 
           run(command, options, &sudo_behavior_callback(block))
         end
@@ -83,9 +84,9 @@ module Capistrano
           # was wrong, let's track which host prompted first and only allow
           # subsequent prompts from that host.
           prompt_host = nil
-          
+
           Proc.new do |ch, stream, out|
-            if out =~ /password:/i
+            if out =~ /^#{Regexp.escape(sudo_prompt)}/
               ch.send_data "#{self[:password]}\n"
             elsif out =~ /try again/
               if prompt_host.nil? || prompt_host == ch[:server]
@@ -110,7 +111,8 @@ module Capistrano
         #   Otherwise, if the :default_shell key exists in the configuration,
         #   it will be used. Otherwise, no :shell key is added.
         def add_default_command_options(options)
-          options = options.dup
+          defaults = self[:default_run_options]
+          options = defaults.merge(options)
 
           env = self[:default_environment]
           env = env.merge(options[:env]) if options[:env]
@@ -121,6 +123,11 @@ module Capistrano
 
           options
         end
+
+        # Returns the prompt text to use with sudo
+        def sudo_prompt
+          fetch(:sudo_prompt, "sudo password: ")
+        end
       end
     end
   end

data/lib/capistrano/configuration/loading.rb

@@ -25,6 +25,28 @@ module Capistrano
         def instance=(config)
           Thread.current[:capistrano_configuration] = config
         end
+
+        # Used internally by Capistrano to track which recipes have been loaded
+        # via require, so that they may be successfully reloaded when require
+        # is called again.
+        def recipes_per_feature
+          @recipes_per_feature ||= {}
+        end
+
+        # Used internally to determine what the current "feature" being
+        # required is. This is used to track which files load which recipes
+        # via require.
+        def current_feature
+          Thread.current[:capistrano_current_feature]
+        end
+
+        # Used internally to specify the current file being required, so that
+        # any recipes loaded by that file can be remembered. This allows
+        # recipes loaded via require to be correctly reloaded in different
+        # Configuration instances in the same Ruby instance.
+        def current_feature=(feature)
+          Thread.current[:capistrano_current_feature] = feature
+        end
       end
 
       # The load paths used for locating recipe files.
@@ -33,6 +55,7 @@ module Capistrano
       def initialize_with_loading(*args) #:nodoc:
         initialize_without_loading(*args)
         @load_paths = [".", File.expand_path(File.join(File.dirname(__FILE__), "../recipes"))]
+        @loaded_features = []
       end
       private :initialize_with_loading
 
@@ -66,9 +89,11 @@ module Capistrano
           load_from_file(options[:file], options[:name])
 
         elsif options[:string]
+          remember_load(options) unless options[:reloading]
           instance_eval(options[:string], options[:name] || "<eval>")
 
         elsif options[:proc]
+          remember_load(options) unless options[:reloading]
           instance_eval(&options[:proc])
 
         else
@@ -80,12 +105,63 @@ module Capistrano
       # with the exception that it sets the receiver as the "current" configuration
       # so that third-party task bundles can include themselves relative to
       # that configuration.
+      #
+      # This is a bit more complicated than an initial review would seem to
+      # necessitate, but the use case that complicates things is this: An
+      # advanced user wants to embed capistrano, and needs to instantiate
+      # more than one capistrano configuration at a time. They also want each
+      # configuration to require a third-party capistrano extension. Using a
+      # naive require implementation, this would allow the first configuration
+      # to successfully load the third-party extension, but the require would
+      # fail for the second configuration because the extension has already
+      # been loaded.
+      #
+      # To work around this, we do a few things:
+      #
+      # 1. Each time a 'require' is invoked inside of a capistrano recipe,
+      #    we remember the arguments (see "current_feature").
+      # 2. Each time a 'load' is invoked inside of a capistrano recipe, and
+      #    "current_feature" is not nil (meaning we are inside of a pending
+      #    require) we remember the options (see "remember_load" and
+      #    "recipes_per_feature").
+      # 3. Each time a 'require' is invoked inside of a capistrano recipe,
+      #    we check to see if this particular configuration has ever seen these
+      #    arguments to require (see @loaded_features), and if not, we proceed
+      #    as if the file had never been required. If the superclass' require
+      #    returns false (meaning, potentially, that the file has already been
+      #    required), then we look in the recipes_per_feature collection and
+      #    load any remembered recipes from there.
+      #
+      # It's kind of a bear, but it works, and works transparently. Note that
+      # a simpler implementation would just muck with $", allowing files to be
+      # required multiple times, but that will cause warnings (and possibly
+      # errors) if the file to be required contains constant definitions and
+      # such, alongside (or instead of) capistrano recipe definitions.
       def require(*args) #:nodoc:
-        original, self.class.instance = self.class.instance, self
-        super
-      ensure
-        # restore the original, so that require's can be nested
-        self.class.instance = original
+        # look to see if this specific configuration instance has ever seen
+        # these arguments to require before
+        if !@loaded_features.include?(args)
+          @loaded_features << args
+
+          begin
+            original_instance, self.class.instance = self.class.instance, self
+            original_feature, self.class.current_feature = self.class.current_feature, args
+
+            result = super
+            if !result # file has been required previously, load up the remembered recipes
+              list = self.class.recipes_per_feature[args] || []
+              list.each { |options| load(options.merge(:reloading => true)) }
+            end
+
+            return result
+          ensure
+            # restore the original, so that require's can be nested
+            self.class.instance = original_instance
+            self.class.current_feature = original_feature
+          end
+        else
+          return false
+        end
       end
 
       private
@@ -107,6 +183,16 @@ module Capistrano
 
           raise LoadError, "no such file to load -- #{file}"
         end
+
+        # If a file is being required, the options associated with loading a
+        # recipe are remembered in the recipes_per_feature archive under the
+        # name of the file currently being required.
+        def remember_load(options)
+          if self.class.current_feature
+            list = (self.class.recipes_per_feature[self.class.current_feature] ||= [])
+            list << options
+          end
+        end
     end
   end
 end

data/lib/capistrano/configuration/namespaces.rb

@@ -32,6 +32,12 @@ module Capistrano
       end
       private :initialize_with_namespaces
 
+      # Returns the top-level namespace (the one with no parent).
+      def top
+        return parent.top if parent
+        return self
+      end
+
       # Returns the fully-qualified name of this namespace, or nil if the
       # namespace is at the top-level.
       def fully_qualified_name

data/lib/capistrano/recipes/deploy.rb

@@ -39,9 +39,14 @@ _cset(:real_revision)     { source.local.query_revision(revision) { |cmd| with_e
 _cset(:strategy)          { Capistrano::Deploy::Strategy.new(deploy_via, self) }
 
 _cset(:release_name)      { set :deploy_timestamped, true; Time.now.utc.strftime("%Y%m%d%H%M%S") }
-_cset(:releases_path)     { File.join(deploy_to, "releases") }
-_cset(:shared_path)       { File.join(deploy_to, "shared") }
-_cset(:current_path)      { File.join(deploy_to, "current") }
+
+_cset :version_dir,       "releases"
+_cset :shared_dir,        "shared"
+_cset :current_dir,       "current"
+
+_cset(:releases_path)     { File.join(deploy_to, version_dir) }
+_cset(:shared_path)       { File.join(deploy_to, shared_dir) }
+_cset(:current_path)      { File.join(deploy_to, current_dir) }
 _cset(:release_path)      { File.join(releases_path, release_name) }
 
 _cset(:releases)          { capture("ls -x #{releases_path}").split.sort }
@@ -224,21 +229,26 @@ namespace :deploy do
     abort "Please specify at least one file to update (via the FILES environment variable)" if files.empty?
 
     files.each do |file|
-      put File.read(file), File.join(current_path, file)
+      content = File.open(file, "rb") { |f| f.read }
+      put content, File.join(current_path, file)
     end
   end
 
   desc <<-DESC
     Restarts your application. This works by calling the script/process/reaper \
-    script under the current path. By default, this will be invoked via sudo, \
-    but if you are in an environment where sudo is not an option, or is not \
-    allowed, you can indicate that restarts should use `run' instead by \
-    setting the `use_sudo' variable to false:
-
+    script under the current path.
+    
+    By default, this will be invoked via sudo as the `app' user. If \
+    you wish to run it as a different user, set the :runner variable to \
+    that user. If you are in an environment where you can't use sudo, set \
+    the :use_sudo variable to false:
+    
       set :use_sudo, false
   DESC
   task :restart, :roles => :app, :except => { :no_release => true } do
-    invoke_command "#{current_path}/script/process/reaper", :via => run_method
+    as = fetch(:runner, "app")
+    via = fetch(:run_method, :sudo)
+    invoke_command "#{current_path}/script/process/reaper", :via => via, :as => as
   end
 
   desc <<-DESC
@@ -436,7 +446,8 @@ namespace :deploy do
       might not be supported on all SCM's.
     DESC
     task :default, :except => { :no_release => true } do
-      system(source.local.log(current_revision))
+      from = source.next_revision(current_revision)
+      system(source.local.log(from))
     end
   end
 

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

@@ -34,6 +34,36 @@ module Capistrano
         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
@@ -55,6 +85,7 @@ module Capistrano
         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

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

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