switchtower 0.9.0 → 0.10.0

data/lib/switchtower/actor.rb

@@ -1,5 +1,6 @@
 require 'erb'
 require 'switchtower/command'
+require 'switchtower/transfer'
 require 'switchtower/gateway'
 require 'switchtower/ssh'
 
@@ -27,10 +28,12 @@ module SwitchTower
     class <<self
       attr_accessor :connection_factory
       attr_accessor :command_factory
+      attr_accessor :transfer_factory
     end
 
     self.connection_factory = DefaultConnectionFactory
     self.command_factory = Command
+    self.transfer_factory = Transfer
 
     # The configuration instance associated with this actor.
     attr_reader :configuration
@@ -63,6 +66,7 @@ module SwitchTower
 
       def initialize(name, options)
         @name, @options = name, options
+        @servers = nil
       end
 
       # Returns the list of servers (_not_ connections to servers) that are
@@ -107,7 +111,7 @@ module SwitchTower
         logger.trace "executing task #{name}"
         begin
           push_task_call_frame name
-          result = instance_eval &block
+          result = instance_eval(&block)
         ensure
           pop_task_call_frame
         end
@@ -131,15 +135,7 @@ module SwitchTower
 
       logger.debug "executing #{cmd.strip.inspect}"
 
-      # get the currently executing task and determine which servers it uses
-      servers = tasks[task_call_frames.last.name].servers(configuration)
-      servers = servers.first if options[:once]
-      logger.trace "servers: #{servers.inspect}"
-
-      if !pretend
-        # establish connections to those servers, as necessary
-        establish_connections(servers)
-
+      execute_on_servers(options) do |servers|
         # execute the command on each server in parallel
         command = self.class.command_factory.new(servers, cmd, block, options, self)
         command.process! # raises an exception if command fails on any server
@@ -158,13 +154,21 @@ module SwitchTower
     # the current task. If <tt>:mode</tt> is specified it is used to set the
     # mode on the file.
     def put(data, path, options={})
-      # Poor-man's SFTP... just run a cat on the remote end, and send data
-      # to it.
+      if SwitchTower::SFTP
+        execute_on_servers(options) do |servers|
+          transfer = self.class.transfer_factory.new(servers, self, path, :data => data,
+            :mode => options[:mode])
+          transfer.process!
+        end
+      else
+        # Poor-man's SFTP... just run a cat on the remote end, and send data
+        # to it.
 
-      cmd = "cat > #{path}"
-      cmd << " && chmod #{options[:mode].to_s(8)} #{path}" if options[:mode]
-      run(cmd, options.merge(:data => data + "\n\4")) do |ch, stream, out|
-        logger.important out, "#{stream} :: #{ch[:host]}" if out == :err
+        cmd = "cat > #{path}"
+        cmd << " && chmod #{options[:mode].to_s(8)} #{path}" if options[:mode]
+        run(cmd, options.merge(:data => data + "\n\4")) do |ch, stream, out|
+          logger.important out, "#{stream} :: #{ch[:host]}" if stream == :err
+        end
       end
     end
 
@@ -176,9 +180,23 @@ module SwitchTower
         logger.debug(out, "#{stream} :: #{ch[:host]}")
       end
 
+      # in order to prevent _each host_ from prompting when the password was
+      # wrong, let's track which host prompted first and only allow subsequent
+      # prompts from that host.
+      prompt_host = nil
+      
       run "sudo #{command}", options do |ch, stream, out|
         if out =~ /^Password:/
           ch.send_data "#{password}\n"
+        elsif out =~ /try again/
+          if prompt_host.nil? || prompt_host == ch[:host]
+            prompt_host = ch[:host]
+            logger.important out, "#{stream} :: #{ch[:host]}"
+            # reset the password to it's original value and prepare for another
+            # pass (the reset allows the password prompt to be attempted again
+            # if the password variable was originally a proc (the default)
+            set :password, self[:original_value][:password] || self[:password]
+          end
         else
           block.call(ch, stream, out)
         end
@@ -339,6 +357,18 @@ module SwitchTower
         gateway && !@established_gateway
       end
 
+      def execute_on_servers(options)
+        servers = tasks[task_call_frames.last.name].servers(configuration)
+        servers = servers.first if options[:once]
+        logger.trace "servers: #{servers.inspect}"
+
+        if !pretend
+          # establish connections to those servers, as necessary
+          establish_connections(servers)
+          yield servers
+        end
+      end
+
       def method_missing(sym, *args, &block)
         if @configuration.respond_to?(sym)
           @configuration.send(sym, *args, &block)

data/lib/switchtower/cli.rb

@@ -2,11 +2,19 @@ require 'optparse'
 require 'switchtower'
 
 module SwitchTower
+  # The CLI class encapsulates the behavior of switchtower when it is invoked
+  # as a command-line utility. This allows other programs to embed ST and
+  # preserve it's command-line semantics.
   class CLI
+    # Invoke switchtower using the ARGV array as the option parameters. This
+    # is what the command-line switchtower utility does.
     def self.execute!
       new.execute!
     end
 
+    # The following determines whether or not echo-suppression is available.
+    # This requires the termios library to be installed (which, unfortunately,
+    # is not available for Windows).
     begin
       if !defined?(USE_TERMIOS) || USE_TERMIOS
         require 'termios'
@@ -15,7 +23,7 @@ module SwitchTower
       end
 
       # Enable or disable stdin echoing to the terminal.
-      def echo(enable)
+      def self.echo(enable)
         term = Termios::getattr(STDIN)
 
         if enable
@@ -27,13 +35,64 @@ module SwitchTower
         Termios::setattr(STDIN, Termios::TCSANOW, term)
       end
     rescue LoadError
-      def echo(enable)
+      def self.echo(enable)
       end
     end
 
-    attr_reader :options
+    # execute the associated block with echo-suppression enabled. Note that
+    # if termios is not available, echo suppression will not be available
+    # either.
+    def self.with_echo
+      echo(false)
+      yield
+    ensure
+      echo(true)
+    end
+
+    # Prompt for a password using echo suppression.
+    def self.password_prompt(prompt="Password: ")
+      sync = STDOUT.sync
+      begin
+        with_echo do
+          STDOUT.sync = true
+          print(prompt)
+          STDIN.gets.chomp
+        end
+      ensure
+        STDOUT.sync = sync
+        puts
+      end
+    end
+
+    # The array of (unparsed) command-line options
     attr_reader :args
 
+    # The hash of (parsed) command-line options
+    attr_reader :options
+
+    # Create a new CLI instance using the given array of command-line parameters
+    # to initialize it. By default, +ARGV+ is used, but you can specify a
+    # different set of parameters (such as when embedded ST in a program):
+    #
+    #   require 'switchtower/cli'
+    #   SwitchTower::CLI.new(%w(-vvvv -r config/deploy -a update_code)).execute!
+    #
+    # Note that you can also embed ST directly by creating a new Configuration
+    # instance and setting it up, but you'll often wind up duplicating logic
+    # defined in the CLI class. The above snippet, redone using the Configuration
+    # class directly, would look like:
+    #
+    #   require 'switchtower'
+    #   require 'switchtower/cli'
+    #   config = SwitchTower::Configuration.new
+    #   config.logger_level = SwitchTower::Logger::TRACE
+    #   config.set :password, Proc.new { SwitchTower::CLI.password_prompt }
+    #   config.load "standard", "config/deploy"
+    #   config.actor.update_code
+    #
+    # There may be times that you want/need the additional control offered by
+    # manipulating the Configuration directly, but generally interfacing with
+    # the CLI class is recommended.
     def initialize(args = ARGV)
       @args = args
       @options = { :verbose => 0, :recipes => [], :actions => [], :vars => {},
@@ -120,7 +179,7 @@ module SwitchTower
         end
 
         opts.separator ""
-        opts.separator <<DETAIL.split(/\n/)
+        opts.separator <<-DETAIL.split(/\n/)
 You can use the --apply-to switch to generate a minimal set of switchtower
 scripts and recipes for an application. Just specify the path to the application
 as the argument to --apply-to, like this:
@@ -143,19 +202,7 @@ DETAIL
 
       check_options!
 
-      password_proc = Proc.new do
-        sync = STDOUT.sync
-        begin
-          echo false
-          STDOUT.sync = true
-          print "Password: "
-          STDIN.gets.chomp
-        ensure
-          echo true
-          STDOUT.sync = sync
-          puts
-        end
-      end
+      password_proc = Proc.new { self.class.password_prompt }
 
       if !@options.has_key?(:password)
         @options[:password] = password_proc
@@ -164,6 +211,7 @@ DETAIL
       end
     end
 
+    # Beginning running SwitchTower based on the configured options.
     def execute!
       if !@options[:recipes].empty?
         execute_recipes!
@@ -174,6 +222,8 @@ DETAIL
 
     private
 
+      # Load the recipes specified by the options, and execute the actions
+      # specified.
       def execute_recipes!
         config = SwitchTower::Configuration.new
         config.logger.level = options[:verbose]
@@ -192,6 +242,7 @@ DETAIL
         options[:actions].each { |action| actor.send action }
       end
 
+      # Load the Rails generator and apply it to the specified directory.
       def execute_apply_to!
         require 'switchtower/generators/rails/loader'
         Generators::RailsLoader.load! @options
@@ -200,6 +251,7 @@ DETAIL
       APPLY_TO_OPTIONS = [:apply_to]
       RECIPE_OPTIONS   = [:password]
 
+      # A sanity check to ensure that a valid operation is specified.
       def check_options!
         apply_to_given = !(@options.keys & APPLY_TO_OPTIONS).empty?
         recipe_given   = !(@options.keys & RECIPE_OPTIONS).empty? ||

data/lib/switchtower/command.rb

@@ -24,6 +24,7 @@ module SwitchTower
     def process!
       logger.debug "processing command"
 
+      since = Time.now
       loop do
         active = 0
         @channels.each do |ch|
@@ -33,6 +34,11 @@ module SwitchTower
         end
 
         break if active == 0
+        if Time.now - since >= 1
+          since = Time.now
+          @channels.each { |ch| ch.connection.ping! }
+        end
+        sleep 0.01 # a brief respite, to keep the CPU from going crazy
       end
 
       logger.trace "command finished"

data/lib/switchtower/configuration.rb

@@ -3,7 +3,6 @@ require 'switchtower/logger'
 require 'switchtower/scm/subversion'
 
 module SwitchTower
-
   # Represents a specific SwitchTower configuration. A Configuration instance
   # may be used to load multiple recipe files, define and describe tasks,
   # define roles, create an actor, and set configuration variables.
@@ -38,12 +37,17 @@ module SwitchTower
       @variables = {}
       @now = Time.now.utc
 
+      # for preserving the original value of Proc-valued variables
+      set :original_value, Hash.new
+
       set :application, nil
       set :repository,  nil
       set :gateway,     nil
       set :user,        nil
       set :password,    nil
-
+      
+      set :ssh_options, Hash.new
+						
       set :deploy_to,   Proc.new { "/u/apps/#{application}" }
 
       set :version_dir, DEFAULT_VERSION_DIR_NAME
@@ -61,10 +65,14 @@ module SwitchTower
 
     alias :[]= :set
 
-    # Access a named variable. If the value of the variable is a Proc instance,
-    # the proc will be invoked and the return value cached and returned.
+    # Access a named variable. If the value of the variable responds_to? :call,
+    # #call will be invoked (without parameters) and the return value cached
+    # and returned.
     def [](variable)
-      set variable, @variables[variable].call if Proc === @variables[variable]
+      if @variables[variable].respond_to?(:call)
+        self[:original_value][variable] = @variables[variable]
+        set variable, @variables[variable].call
+      end
       @variables[variable]
     end
 

data/lib/switchtower/generators/rails/deployment/templates/deploy.rb

@@ -38,6 +38,12 @@ role :db,  "db02.example.com", "db03.example.com"
 # set :cvs, "/path/to/cvs"       # defaults to searching the PATH
 # set :gateway, "gate.host.com"  # default to no gateway
 
+# =============================================================================
+# SSH OPTIONS
+# =============================================================================
+# ssh_options[:keys] = %w(/path/to/my/key /path/to/another/key)
+# ssh_options[:port] = 25
+
 # =============================================================================
 # TASKS
 # =============================================================================

data/lib/switchtower/generators/rails/deployment/templates/switchtower.rake

@@ -2,32 +2,47 @@
 # A set of rake tasks for invoking the SwitchTower automation utility.
 # =============================================================================
 
-desc "Push the latest revision into production using the release manager"
+# Invoke the given actions via SwitchTower
+def switchtower_invoke(*actions)
+  begin
+    require 'rubygems'
+  rescue LoadError
+    # no rubygems to load, so we fail silently
+  end
+
+  require 'switchtower/cli'
+
+  args = %w[-vvvvv -r config/<%= recipe_file %>]
+  args.concat(actions.map { |act| ["-a", act.to_s] }.flatten)
+  SwitchTower::CLI.new(args).execute!
+end
+
+desc "Push the latest revision into production"
 task :deploy do
-  system "switchtower -vvvv -r config/<%= recipe_file %> -a deploy"
+  switchtower_invoke :deploy
 end
 
 desc "Rollback to the release before the current release in production"
 task :rollback do
-  system "switchtower -vvvv -r config/<%= recipe_file %> -a rollback"
+  switchtower_invoke :rollback
 end
 
 desc "Describe the differences between HEAD and the last production release"
 task :diff_from_last_deploy do
-  system "switchtower -vvvv -r config/<%= recipe_file %> -a diff_from_last_deploy"
+  switchtower_invoke :diff_from_last_deploy
 end
 
 desc "Enumerate all available deployment tasks"
 task :show_deploy_tasks do
-  system "switchtower -r config/<%= recipe_file %> -a show_tasks"
+  switchtower_invoke :show_tasks
 end
 
-desc "Execute a specific action using the release manager"
+desc "Execute a specific action using switchtower"
 task :remote_exec do
   unless ENV['ACTION']
     raise "Please specify an action (or comma separated list of actions) via the ACTION environment variable"
   end
 
-  actions = ENV['ACTION'].split(",").map { |a| "-a #{a}" }.join(" ")
-  system "switchtower -vvvv -r config/<%= recipe_file %> #{actions}"
+  actions = ENV['ACTION'].split(",")
+  switchtower_invoke(*actions)
 end

data/lib/switchtower/recipes/standard.rb

@@ -4,12 +4,18 @@
 #   application servers.
 # * The :web role has been defined as the set of machines consisting of the
 #   web servers.
-# * The Rails spinner and reaper scripts are being used to manage the FCGI
+# * The :db role has been defined as the set of machines consisting of the
+#   databases, with exactly one set up as the :primary DB server.
+# * The Rails spawner and reaper scripts are being used to manage the FCGI
 #   processes.
-# * There is a script in script/ called "reap" that restarts the FCGI processes
 
 set :rake, "rake"
 
+set :migrate_target, :current
+set :migrate_env, ""
+
+set :restart_via, :sudo
+
 desc "Enumerate and describe every available task."
 task :show_tasks do
   keys = tasks.keys.sort_by { |a| a.to_s }
@@ -91,14 +97,15 @@ task :symlink, :roles => [:app, :db, :web] do
   run "ln -nfs #{current_release} #{current_path}"
 end
 
-desc "Restart the FCGI processes on the app server."
+desc <<-DESC
+Restart the FCGI processes on the app server. This uses the :restart_via
+variable to determine whether to use sudo or not. By default, :restart_via is
+set to :sudo, but you can set it to :run if you are in a shared environment.
+DESC
 task :restart, :roles => :app do
-  sudo "#{current_path}/script/process/reaper"
+  send(restart_via, "#{current_path}/script/process/reaper")
 end
 
-set :migrate_target, :current
-set :migrate_env, ""
-
 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,7 +144,7 @@ end
 
 desc <<-DESC
 Similar to deploy, but it runs the migrate task on the new release before
-updating the symlink. (Note that the update in this case is not atomic,
+updating the symlink. (Note that the update in this case it is not atomic,
 and transactions are not used, because migrations are not guaranteed to be
 reversible.)
 DESC
@@ -173,3 +180,26 @@ task :diff_from_last_deploy do
   puts diff
   puts
 end
+
+desc "Update the currently released version of the software directly via an SCM update operation"
+task :update_current do
+  source.update(self)
+end
+
+desc <<-DESC
+Removes unused releases from the releases directory. By default, the last 5
+releases are retained, but this can be configured with the 'keep_releases'
+variable.
+DESC
+task :cleanup do
+  count = (self[:keep_releases] || 5).to_i
+  if count >= releases.length
+    logger.important "no old releases to clean up"
+  else
+    logger.info "keeping #{count} of #{releases.length} deployed releases"
+    keepers = (releases - releases.last(count)).map { |release|
+      File.join(releases_path, release) }.join(" ")
+
+    sudo "rm -rf #{keepers}"
+  end
+end

data/lib/switchtower/scm/base.rb

@@ -21,6 +21,10 @@ module SwitchTower
         raise "#{self.class} doesn't support diff(from, to)"
       end
 
+      def update(actor)
+        raise "#{self.class} doesn't support update(actor)"
+      end
+
       private
 
         def run_checkout(actor, guts, &block)
@@ -30,13 +34,28 @@ module SwitchTower
           command = <<-STR
             if [[ ! -d #{configuration.release_path} ]]; then
               #{guts}
-              echo `date +"%Y-%m-%d %H:%M:%S"` $USER #{configuration.revision} #{directory} >> #{log};
-              chmod 666 #{log};
+              #{logging_commands(directory)}
             fi
           STR
 
           actor.run(command, &block)
         end
+        
+        def run_update(actor, guts, &block)
+          command = <<-STR
+            #{guts}
+            #{logging_commands}
+          STR
+
+          actor.run(command, &block)
+        end
+
+        def logging_commands(directory = nil)
+          log = "#{configuration.deploy_to}/revisions.log"
+
+          "echo `date +\"%Y-%m-%d %H:%M:%S\"` $USER #{configuration.revision} #{directory} >> #{log} && " +
+          "chmod 666 #{log};"
+        end
     end
 
   end

data/lib/switchtower/scm/subversion.rb

@@ -67,37 +67,50 @@ module SwitchTower
       # the requested password is the same as the password for logging into the
       # remote server.)
       def checkout(actor)
-        svn = configuration[:svn] ? configuration[:svn] : "svn"
-
-        command = "#{svn} co -q -r#{configuration.revision} #{configuration.repository} #{actor.release_path};"
+        op = configuration[:checkout] || "co"
+        command = "#{svn} #{op} -q -r#{configuration.revision} #{configuration.repository} #{actor.release_path} &&"
+        run_checkout(actor, command, &svn_stream_handler(actor)) 
+      end
 
-        run_checkout(actor, command) do |ch, stream, out|
-          prefix = "#{stream} :: #{ch[:host]}"
-          actor.logger.info out, prefix
-          if out =~ /^Password.*:/
-            actor.logger.info "subversion is asking for a password", prefix
-            ch.send_data "#{actor.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
+      # 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_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 "#{actor.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

data/lib/switchtower/ssh.rb

@@ -1,6 +1,16 @@
 require 'net/ssh'
 
 module SwitchTower
+  unless ENV['SKIP_VERSION_CHECK']
+    require 'switchtower/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
@@ -14,12 +24,11 @@ module SwitchTower
       password_value = nil
 
       begin
-        Net::SSH.start(server,
-          :username => config.user,
-          :password => password_value,
-          :port => port,
-          :auth_methods => methods.shift,
-          &block)
+        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

data/lib/switchtower/transfer.rb

@@ -0,0 +1,90 @@
+begin
+  require 'switchtower/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 !SwitchTower::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."
+    SwitchTower::SFTP = false
+  else
+    SwitchTower::SFTP = true
+  end
+rescue LoadError
+  SwitchTower::SFTP = false
+end
+
+module SwitchTower
+
+  # 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, @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/switchtower/version.rb

@@ -1,9 +1,30 @@
 module SwitchTower
   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 = 0
-    MINOR = 9
+    MINOR = 10
     TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join(".")
+    
+    SSH_REQUIRED = [1,0,5]
+    SFTP_REQUIRED = [1,1,0]
   end
 end

data/test/configuration_test.rb

@@ -207,4 +207,12 @@ class ConfigurationTest < Test::Unit::TestCase
     @config.set :scm, :subversion
     assert_equal "SwitchTower::SCM::Subversion", @config.source.class.name
   end
+
+  def test_get_proc_variable_sets_original_value_hash
+    @config.set :proc, Proc.new { "foo" }
+    assert_nil @config[:original_value][:proc]
+    assert_equal "foo", @config[:proc]
+    assert_not_nil @config[:original_value][:proc]
+    assert @config[:original_value][:proc].respond_to?(:call)
+  end
 end

data/test/scm/subversion_test.rb

@@ -51,6 +51,7 @@ class ScmSubversionTest < Test::Unit::TestCase
 
   def setup
     @config = MockConfiguration.new
+    @config[:current_path] = "/mwa/ha/ha/current"
     @config[:repository] = "/hello/world"
     @config[:svn] = "/path/to/svn"
     @config[:password] = "chocolatebrownies"
@@ -86,6 +87,21 @@ MSG
     assert_match %r{/path/to/svn}, @actor.command
   end
 
+  def test_checkout_via_export
+    @actor.story = []
+    @config[:checkout] = "export"
+    assert_nothing_raised { @scm.checkout(@actor) }
+    assert_nil @actor.channels.last.sent_data
+    assert_match %r{/path/to/svn export}, @actor.command
+  end
+
+  def test_update
+    @actor.story = []
+    assert_nothing_raised { @scm.update(@actor) }
+    assert_nil @actor.channels.last.sent_data
+    assert_match %r{/path/to/svn up}, @actor.command
+  end
+
   def test_checkout_needs_ssh_password
     @actor.story = [[:out, "Password: "]]
     assert_nothing_raised { @scm.checkout(@actor) }
@@ -97,4 +113,10 @@ MSG
     assert_nothing_raised { @scm.checkout(@actor) }
     assert_equal ["chocolatebrownies\n"], @actor.channels.last.sent_data
   end
+
+  def test_checkout_needs_alternative_ssh_password
+    @actor.story = [[:out, "someone's password: "]]
+    assert_nothing_raised { @scm.checkout(@actor) }
+    assert_equal ["chocolatebrownies\n"], @actor.channels.last.sent_data
+  end
 end

data/test/utils.rb

@@ -25,6 +25,7 @@ class MockConfiguration < Hash
   def initialize(*args)
     super
     self[:release_path] = "/path/to/releases/version"
+    self[:ssh_options] = {}
   end
 
   def logger

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.10
+rubygems_version: 0.8.11
 specification_version: 1
 name: switchtower
 version: !ruby/object:Gem::Version 
-  version: 0.9.0
-date: 2005-10-18
+  version: 0.10.0
+date: 2006-01-02 00:00:00 -07:00
 summary: "SwitchTower is a framework and utility for executing commands in parallel     on
   multiple remote machines, via SSH. The primary goal is to simplify and    
   automate the deployment of web applications."
@@ -26,6 +26,8 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
         version: 0.0.0
   version: 
 platform: ruby
+signing_key: 
+cert_chain: 
 authors: 
   - Jamis Buck
 files: 
@@ -42,6 +44,7 @@ files:
   - lib/switchtower/recipes
   - lib/switchtower/scm
   - lib/switchtower/ssh.rb
+  - lib/switchtower/transfer.rb
   - lib/switchtower/version.rb
   - lib/switchtower/generators/rails
   - lib/switchtower/generators/rails/deployment
@@ -84,5 +87,15 @@ dependencies:
         - 
           - ">="
           - !ruby/object:Gem::Version 
-            version: 1.0.2
+            version: 1.0.5
+      version: 
+  - !ruby/object:Gem::Dependency 
+    name: net-sftp
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Version::Requirement 
+      requirements: 
+        - 
+          - ">="
+          - !ruby/object:Gem::Version 
+            version: 1.1.0
       version: