capistrano 1.1.0

data/lib/capistrano/scm/perforce.rb

@@ -0,0 +1,139 @@
+require 'capistrano/scm/base'
+
+module Capistrano
+  module SCM
+
+    # An SCM module for using perforce as your source control tool. 
+    # This module can explicitly selected by placing the following line 
+    # in your configuration:
+    #
+    #   set :scm, :perforce
+    #
+    # Also, this module accepts a <tt>:p4</tt> configuration variable,
+    # which (if specified) will be used as the full path to the p4
+    # executable on the remote machine:
+    #
+    #   set :p4, "/usr/local/bin/p4"
+    #
+    # This module accepts another <tt>:p4sync_flags</tt> configuration 
+    # variable, which (if specified) can add extra options. This setting
+    # defaults to the value "-f" which forces resynchronization.
+    #
+    #   set :p4sync_flags, "-f"        
+    #
+    # This module accepts another <tt>:p4client_root</tt> configuration 
+    # variable to handle mapping adjustments.  Perforce doesn't have the 
+    # ability to sync to a specific directory (e.g. the release_path); the
+    # location being synced to is defined by the client-spec. As such, we 
+    # sync the client-spec (defined by <tt>p4client</tt> and then copy from 
+    # the determined root of the client-spec mappings to the release_path.
+    # In the unlikely event that your client-spec mappings introduces 
+    # directory structure above the rails structure, you can override the
+    # may need to specify the directory
+    #
+    #   set :p4client_root, "/user/rmcmahon/project1/code"            
+    #
+    # Finally, the module accepts a <tt>p4diff2_options</tt> configuration
+    # variable. This can be used to manipulate the output when running a
+    # diff between what is deployed, and another revision. This option
+    # defaults to "-u". Run 'p4 help diff2' for other options.
+    #
+    class Perforce < Base
+
+      def latest_revision
+        configuration.logger.debug "querying latest revision..." unless @latest_revision
+        @latest_revision = `#{local_p4} counter change`.strip
+        @latest_revision
+      end
+      
+      # Return the number of the revision currently deployed.
+      def current_revision(actor)
+        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 revision" if str == :err
+        end
+
+        date, time, user, rev, dir = result.split
+        raise "current revision not found in revisions.log" unless dir == latest
+        rev.to_i
+      end
+      
+      # Return a string containing the diff between the two revisions. +from+
+      # and +to+ may be in any format that p4 recognizes as a valid revision
+      # identifiers. If +from+ is +nil+, it defaults to the last deployed
+      # revision. If +to+ is +nil+, it defaults to #head.
+      def diff(actor, from=nil, to=nil)
+        from ||= "@#{current_revision(actor)}"
+        to ||= "#head"
+        p4client = configuration[:p4client]
+        p4diff2_options = configuration[:p4diff2_options]||"-u -db"
+        `#{local_p4} diff2 #{p4diff2_options} //#{p4client}/...#{from} //#{p4client}/...#{to}`
+      end      
+      
+      # Syncronizes (on all servers associated with the current task) the head
+      # revision of the code. Uses the given actor instance to execute the command. 
+      #
+      def checkout(actor)
+        p4sync_flags = configuration[:p4sync_flags] || "-f"
+        p4client_root = configuration[:p4client_root] || "`#{remote_p4} client -o | grep ^Root | cut -f2`"
+        command = "#{remote_p4} sync #{p4sync_flags} && cp -rf #{p4client_root} #{actor.release_path};"
+        run_checkout(actor, command, &p4_stream_handler(actor)) 
+      end
+
+      def update(actor)
+        raise "#{self.class} doesn't support update(actor)"
+      end
+
+      private
+
+        def local_p4	  
+          add_standard_p4_options('p4')
+        end
+
+        def remote_p4	  
+          p4_cmd = configuration[:p4] || 'p4'
+          add_standard_p4_options(p4_cmd)
+        end
+	
+        def add_standard_p4_options(p4_location)
+          check_settings
+          p4_cmd = p4_location	  
+          p4_cmd = "#{p4_cmd} -p #{configuration[:p4port]}" if configuration[:p4port]
+          p4_cmd = "#{p4_cmd} -u #{configuration[:p4user]}" if configuration[:p4user]
+          p4_cmd = "#{p4_cmd} -P #{configuration[:p4passwd]}" if configuration[:p4passwd]
+          p4_cmd = "#{p4_cmd} -c #{configuration[:p4client]}" if configuration[:p4client]
+          p4_cmd	
+        end
+
+        def check_settings
+          check_setting(:p4port, "Add set :p4port, <your perforce server details e.g. my.p4.server:1666> to deploy.rb")
+          check_setting(:p4user, "Add set :p4user, <your production build username> to deploy.rb")
+          check_setting(:p4passwd, "Add set :p4passwd, <your build user password> to deploy.rb")
+          check_setting(:p4client, "Add set :p4client, <your client-spec name> to deploy.rb")
+        end
+	
+        def check_setting(p4setting, message)
+          raise "#{p4setting} is not configured. #{message}" unless configuration[p4setting]
+        end
+	
+        def p4_stream_handler(actor)
+          Proc.new do |ch, stream, out|
+            prefix = "#{stream} :: #{ch[:host]}"
+            actor.logger.info out, prefix
+            if out =~ /\(P4PASSWD\) invalid or unset\./i
+	            raise "p4passwd is incorrect or unset"
+            elsif out =~ /Can.t create a new user.*/i
+	            raise "p4user is incorrect or unset"
+            elsif out =~ /Perforce client error\:/i	      
+	            raise "p4port is incorrect or unset"
+            elsif out =~ /Client \'[\w\-\_\.]+\' unknown.*/i
+	            raise "p4client is incorrect or unset"
+            end	    
+          end
+        end	
+    end
+  end
+end

data/lib/capistrano/scm/subversion.rb

@@ -0,0 +1,122 @@
+require 'capistrano/scm/base'
+
+module Capistrano
+  module SCM
+
+    # An SCM module for using subversion as your source control tool. This
+    # module is used by default, but you can explicitly specify it by
+    # placing the following line in your configuration:
+    #
+    #   set :scm, :subversion
+    #
+    # Also, this module accepts a <tt>:svn</tt> configuration variable,
+    # which (if specified) will be used as the full path to the svn
+    # executable on the remote machine:
+    #
+    #   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.
+      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)
+          end
+        end
+        @latest_revision
+      end
+
+      # Return the number of the revision currently deployed.
+      def current_revision(actor)
+        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 revision" if str == :err
+        end
+
+        date, time, user, rev, dir = result.split
+        raise "current revision not found in revisions.log" unless dir == latest
+
+        rev.to_i
+      end
+
+      # Return a string containing the diff between the two revisions. +from+
+      # and +to+ may be in any format that svn recognizes as a valid revision
+      # identifier. If +from+ is +nil+, it defaults to the last deployed
+      # revision. If +to+ is +nil+, it defaults to HEAD.
+      def diff(actor, from=nil, to=nil)
+        from ||= current_revision(actor)
+        to ||= "HEAD"
+
+        `svn diff #{configuration.repository}@#{from} #{configuration.repository}@#{to}`
+      end
+
+      # Check out (on all servers associated with the current task) the latest
+      # revision. Uses the given actor instance to execute the command. If
+      # svn 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.)
+      def checkout(actor)
+        op = configuration[:checkout] || "co"
+        username = configuration[:svn_username] ? "--username #{configuration[:svn_username]}" : ""
+        command = "#{svn} #{op} #{username} -q -r#{configuration.revision} #{configuration.repository} #{actor.release_path} &&"
+        run_checkout(actor, command, &svn_stream_handler(actor)) 
+      end
+
+      # Update the current release in-place. This assumes that the original
+      # deployment was made using checkout, and not something like export.
+      def update(actor)
+        command = "cd #{actor.current_path} && #{svn} up -q &&"
+        run_update(actor, command, &svn_stream_handler(actor)) 
+      end
+
+      private
+
+        def svn
+          configuration[:svn] || "svn"
+        end
+
+        def svn_log(path)
+          `svn log -q -rhead #{path}`
+        end
+
+        def svn_password
+          configuration[:svn_password] || configuration[:password]
+        end
+
+        def svn_stream_handler(actor)
+          Proc.new do |ch, stream, out|
+            prefix = "#{stream} :: #{ch[:host]}"
+            actor.logger.info out, prefix
+            if out =~ /\bpassword.*:/i
+              actor.logger.info "subversion is asking for a password", prefix
+              ch.send_data "#{svn_password}\n"
+            elsif out =~ %r{\(yes/no\)}
+              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"
+              actor.logger.info message, prefix
+              ch.send_data "\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
+            end
+          end
+        end
+    end
+
+  end
+end

data/lib/capistrano/ssh.rb

@@ -0,0 +1,39 @@
+require 'net/ssh'
+
+module Capistrano
+  unless ENV['SKIP_VERSION_CHECK']
+    require 'capistrano/version'
+    require 'net/ssh/version'
+    ssh_version = [Net::SSH::Version::MAJOR, Net::SSH::Version::MINOR, Net::SSH::Version::TINY]
+    required_version = [1,0,5]
+    if !Version.check(required_version, ssh_version)
+      raise "You have Net::SSH #{ssh_version.join(".")}, but you need at least #{required_version.join(".")}"
+    end
+  end
+
+  # A helper class for dealing with SSH connections.
+  class SSH
+    # 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.
+    #
+    # 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)
+      methods = [ %w(publickey hostbased), %w(password keyboard-interactive) ]
+      password_value = nil
+
+      begin
+        ssh_options = { :username => config.user,
+                        :password => password_value,
+                        :port => port,
+                        :auth_methods => methods.shift }.merge(config.ssh_options)
+        Net::SSH.start(server,ssh_options,&block)
+      rescue Net::SSH::AuthenticationFailed
+        raise if methods.empty?
+        password_value = config.password
+        retry
+      end
+    end
+  end
+end

data/lib/capistrano/transfer.rb

@@ -0,0 +1,90 @@
+begin
+  require 'capistrano/version'
+  require 'net/sftp'
+  require 'net/sftp/version'
+  sftp_version = [Net::SFTP::Version::MAJOR, Net::SFTP::Version::MINOR, Net::SFTP::Version::TINY]
+  required_version = [1,1,0]
+  if !Capistrano::Version.check(required_version, sftp_version)
+    warn "You have Net::SFTP #{sftp_version.join(".")}, but you need at least #{required_version.join(".")}. Net::SFTP will not be used."
+    Capistrano::SFTP = false
+  else
+    Capistrano::SFTP = true
+  end
+rescue LoadError
+  Capistrano::SFTP = false
+end
+
+module Capistrano
+
+  # This class encapsulates a single file transfer to be performed in parallel
+  # across multiple machines, using the SFTP protocol.
+  class Transfer
+    def initialize(servers, actor, filename, params={}) #:nodoc:
+      @servers = servers
+      @actor = actor
+      @filename = filename
+      @params = params
+      @completed = 0
+      @failed = 0
+      @sftps = setup_transfer
+    end
+    
+    def logger #:nodoc:
+      @actor.logger
+    end
+
+    # Uploads to all specified servers in parallel.
+    def process!
+      logger.debug "uploading #{@filename}"
+
+      loop do
+        @sftps.each { |sftp| sftp.channel.connection.process(true) }
+        break if @completed == @servers.length
+      end
+
+      logger.trace "upload finished"
+
+      if @failed > 0
+        raise "upload of #{@filename} failed on one or more hosts"
+      end
+
+      self
+    end
+
+    private
+
+      def setup_transfer
+        @servers.map do |server|
+          sftp = @actor.sessions[server].sftp
+          sftp.connect unless sftp.state == :open
+
+          sftp.open(@filename, IO::WRONLY | IO::CREAT | IO::TRUNC, @params[:mode] || 0660) do |status, handle|
+            break unless check_status("open #{@filename}", server, status)
+            
+            logger.info "uploading data to #{server}:#{@filename}"
+            sftp.write(handle, @params[:data] || "") do |status|
+              break unless check_status("write to #{server}:#{@filename}", server, status)
+              sftp.close_handle(handle) do
+                logger.debug "done uploading data to #{server}:#{@filename}"
+                @completed += 1
+              end
+            end
+          end
+          
+          sftp
+        end
+      end
+      
+      def check_status(action, server, status)
+        if status.code != Net::SFTP::Session::FX_OK
+          logger.error "could not #{action} on #{server} (#{status.message})"
+          @failed += 1
+          @completed += 1
+          return false
+        end
+        
+        true
+      end
+  end
+
+end

data/lib/capistrano/utils.rb

@@ -0,0 +1,26 @@
+module Capistrano
+  # A helper method for converting a comma-delimited string into an array of
+  # roles.
+  def self.str2roles(string)
+    list = string.split(/,/).map { |s| s.strip.to_sym }
+    list.empty? ? nil : list
+  end
+
+  # Used by third-party task bundles to identify the capistrano configuration
+  # that is loading them. It's return value is not reliable in other contexts.
+  # If +require_config+ is not false, an exception will be raised if the current
+  # configuration is not set.
+  def self.configuration(require_config=false)
+    config = Thread.current[:capistrano_configuration]
+    if require_config && config.nil?
+      raise "Please require this file from within a Capistrano recipe"
+    end
+    config
+  end
+
+  # Used internally by Capistrano to specify the current configuration before
+  # loading a third-party task bundle.
+  def self.configuration=(config)
+    Thread.current[:capistrano_configuration] = config
+  end
+end

data/lib/capistrano/version.rb

@@ -0,0 +1,30 @@
+module Capistrano
+  module Version #:nodoc:
+    # A method for comparing versions of required modules. It expects two
+    # arrays as parameters, and returns true if the first is no more than the
+    # second.
+    def self.check(expected, actual) #:nodoc:
+      good = false
+      if actual[0] > expected[0]
+        good = true
+      elsif actual[0] == expected[0]
+        if actual[1] > expected[1]
+          good = true
+        elsif actual[1] == expected[1] && actual[2] >= expected[2]
+          good = true
+        end
+      end
+    
+      good
+    end
+
+    MAJOR = 1
+    MINOR = 1
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join(".")
+    
+    SSH_REQUIRED = [1,0,8]
+    SFTP_REQUIRED = [1,1,0]
+  end
+end