delano-rye 0.7.2 → 0.7.3

data/CHANGES.txt

@@ -7,6 +7,22 @@ TODO
 * Add S3 support for Rye::Box.upload / download
 
 
+#### 0.7.3 (2009-06-03) #############################
+
+* ADDED: enable_safe_mode and disable_safe_mode methods
+* ADDED: New default Rye::Cmd methods: gzip, bzip, tar and all derivatives. ./configure and make too.
+* ADDED: Rye::Cmd#safely and Rye::Cmd#unsafely methods
+* ADDED: Rye::Cmd#digest_md5, Rye::Cmd#digest_sha1, Rye::Cmd#digest_sha2 methods
+* ADDED: Rye::Cmd#file_verified? method
+* ADDED: Rye::Box#net_ssh_exec! now checks and correctly prompts for a sudo response password. 
+  Note: this will be upgraded in for 0.8 to support any prompt. 
+* FIXED: Net::SSH paranoid now set to false when safe mode is disabled.  
+
+
+#### 0.7.2 (2009-06-01) #############################
+
+*A re-release of 0.7.1 to force Rubyforge to update the gem*
+
 #### 0.7.1 (2009-06-01) #############################
 
 * CHANGE: Removed broken grep method from Rye::Rap

data/lib/rye.rb

@@ -113,9 +113,6 @@ module Rye
     files || []
   end
   
-  
-
-
   # Add one or more private keys to the SSH Agent. 
   # * +keys+ one or more file paths to private keys used for passwordless logins. 
   def add_keys(*keys)

data/lib/rye/box.rb

@@ -36,8 +36,10 @@ module Rye
     
     def host=(val); @rye_host = val; end
     def opts=(val); @rye_opts = val; end
-    def safe=(val); @rye_safe = val; end
-
+    
+    def enable_safe_mode;  @rye_safe = true; end
+    def disable_safe_mode; @rye_safe = false; end
+    
     # The most recent value from Box.cd or Box.[]
     def current_working_directory; @rye_current_working_directory; end
 
@@ -100,7 +102,7 @@ module Rye
       @rye_info = STDOUT if @rye_info == true
       
       @rye_opts[:logger] = Logger.new(@rye_debug) if @rye_debug # Enable Net::SSH debugging
-      @rye_opts[:paranoid] = true unless @rye_opts[:safe] == false # See Net::SSH.start
+      @rye_opts[:paranoid] = true unless @rye_safe == false # See Net::SSH.start
       
       # Add the given private keys to the keychain that will be used for @rye_host
       add_keys(@rye_opts[:keys])
@@ -169,57 +171,6 @@ module Rye
     end
     
     
-    # Open an SSH session with +@rye_host+. This called automatically
-    # when you the first comamnd is run if it's not already connected.
-    # Raises a Rye::NoHost exception if +@rye_host+ is not specified.
-    # Will attempt a password login up to 3 times if the initial 
-    # authentication fails. 
-    # * +reconnect+ Disconnect first if already connected. The default
-    # is true. When set to false, connect will do nothing if already 
-    # connected. 
-    def connect(reconnect=true)
-      raise Rye::NoHost unless @rye_host
-      return if @rye_ssh && !reconnect
-      disconnect if @rye_ssh 
-      debug "Opening connection to #{@rye_host} as #{@rye_opts[:user]}"
-      highline = HighLine.new # Used for password prompt
-      retried = 0
-      
-      begin
-        @rye_ssh = Net::SSH.start(@rye_host, @rye_opts[:user], @rye_opts || {}) 
-      rescue Net::SSH::HostKeyMismatch => ex
-        STDERR.puts ex.message
-        STDERR.puts "NOTE: EC2 instances generate new SSH keys on first boot."
-        print "\a" if @rye_info # Ring the bell
-        if highline.ask("Continue? ").strip.match(/\Ay|yes|sure|ya\z/i)
-          @rye_opts[:paranoid] = false
-          retry
-        else
-          raise Net::SSH::HostKeyMismatch
-        end
-      rescue Net::SSH::AuthenticationFailed => ex
-        print "\a" if retried == 0 && @rye_info # Ring the bell once
-        retried += 1
-        if STDIN.tty? && retried <= 3
-          STDERR.puts "Passwordless login failed for #{@rye_opts[:user]}"
-          @rye_opts[:password] = highline.ask("Password: ") { |q| q.echo = '' }
-          @rye_opts[:auth_methods] ||= []
-          @rye_opts[:auth_methods] << 'password'
-          retry
-        else
-          raise Net::SSH::AuthenticationFailed
-        end
-      end
-      
-      # We add :auth_methods (a Net::SSH joint) to force asking for a
-      # password if the initial (key-based) authentication fails. We
-      # need to delete the key from @rye_opts otherwise it lingers until
-      # the next connection (if we switch_user is called for example).
-      @rye_opts.delete :auth_methods if @rye_opts.has_key?(:auth_methods)
-      
-      self
-    end
-    
     # Reconnect as another user. This is different from su=
     # which executes subsequent commands via +su -c COMMAND USER+. 
     # * +newuser+ The username to reconnect as 
@@ -509,6 +460,26 @@ module Rye
       self.instance_exec *args, &block
     end
     
+    # Like batch, except it disables safe mode before executing the block. 
+    # After executing the block, safe mode is returned back to whichever
+    # state it was previously in. In other words, this method won't enable
+    # safe mode if it was already disabled.
+    def unsafely(*args, &block)
+      previous_state = @rye_safe
+      disable_safe_mode
+      self.instance_exec *args, &block
+      @rye_safe = previous_state
+    end
+    
+    # See unsafely (except in reverse)
+    def safely(*args, &block)
+      previous_state = @rye_safe
+      enable_safe_mode
+      self.instance_exec *args, &block
+      @rye_safe = previous_state
+    end
+    
+    
     # instance_exec for Ruby 1.8 written by Mauricio Fernandez
     # http://eigenclass.org/hiki/instance_exec
     if RUBY_VERSION =~ /1.8/
@@ -539,6 +510,59 @@ module Rye
     end
 
     
+    
+    # Open an SSH session with +@rye_host+. This called automatically
+    # when you the first comamnd is run if it's not already connected.
+    # Raises a Rye::NoHost exception if +@rye_host+ is not specified.
+    # Will attempt a password login up to 3 times if the initial 
+    # authentication fails. 
+    # * +reconnect+ Disconnect first if already connected. The default
+    # is true. When set to false, connect will do nothing if already 
+    # connected. 
+    def connect(reconnect=true)
+      raise Rye::NoHost unless @rye_host
+      return if @rye_ssh && !reconnect
+      disconnect if @rye_ssh 
+      debug "Opening connection to #{@rye_host} as #{@rye_opts[:user]}"
+      highline = HighLine.new # Used for password prompt
+      retried = 0
+      
+      begin
+        @rye_ssh = Net::SSH.start(@rye_host, @rye_opts[:user], @rye_opts || {}) 
+      rescue Net::SSH::HostKeyMismatch => ex
+        STDERR.puts ex.message
+        STDERR.puts "NOTE: EC2 instances generate new SSH keys on first boot."
+        print "\a" if @rye_info # Ring the bell
+        if highline.ask("Continue? ").strip.match(/\Ay|yes|sure|ya\z/i)
+          @rye_opts[:paranoid] = false
+          retry
+        else
+          raise Net::SSH::HostKeyMismatch
+        end
+      rescue Net::SSH::AuthenticationFailed => ex
+        print "\a" if retried == 0 && @rye_info # Ring the bell once
+        retried += 1
+        if STDIN.tty? && retried <= 3
+          STDERR.puts "Passwordless login failed for #{@rye_opts[:user]}"
+          @rye_opts[:password] = highline.ask("Password: ") { |q| q.echo = '' }
+          @rye_opts[:auth_methods] ||= []
+          @rye_opts[:auth_methods] << 'password'
+          retry
+        else
+          raise Net::SSH::AuthenticationFailed
+        end
+      end
+      
+      # We add :auth_methods (a Net::SSH joint) to force asking for a
+      # password if the initial (key-based) authentication fails. We
+      # need to delete the key from @rye_opts otherwise it lingers until
+      # the next connection (if we switch_user is called for example).
+      @rye_opts.delete :auth_methods if @rye_opts.has_key?(:auth_methods)
+      
+      self
+    end
+    
+    
   private
       
     def debug(msg="unknown debug msg"); @rye_debug.puts msg if @rye_debug; end
@@ -582,7 +606,7 @@ module Rye
       
       connect if !@rye_ssh || @rye_ssh.closed?
       raise Rye::NotConnected, @rye_host unless @rye_ssh && !@rye_ssh.closed?
-
+      
       cmd_clean = Rye.escape(@rye_safe, cmd, args)
       cmd_clean = prepend_env(cmd_clean)
       
@@ -660,6 +684,14 @@ module Rye
     
     # Executes +command+ via SSH
     # Returns an Array with 4 elements: [stdout, stderr, exit code, exit signal]
+    # NOTE: This method needs to be replaced to fully support interactive 
+    # commands. This implementation is weird because it's getting just STDOUT and
+    # STDERR responses (check value of "type"). on_data and on_extended_data method
+    # hooks are not used. See the following threads for implementation ideas:
+    #
+    # http://www.ruby-forum.com/topic/141814
+    # http://www.ruby-forum.com/topic/169997
+    #
     def net_ssh_exec!(command)
       
       block ||= Proc.new do |channel, type, data|
@@ -667,7 +699,16 @@ module Rye
         channel[:stderr] ||= ""
         channel[:exit_code] ||= 0
         channel[:stdout] << data if type == :stdout
-        channel[:stderr] << data if type == :stderr
+        if type == :stderr
+          # NOTE: Use sudo to test this since it prompts for a passwords. 
+          # Use sudo -K to kill the user's timestamp (ask for a password every time)
+          if data =~ /Password:/
+            ret = Annoy.get_user_input("Password: ", '*')
+            channel.send_data "#{ret}\n"
+          else
+            channel[:stderr] << data 
+          end
+        end
         channel.on_request("exit-status") do |ch, data|
           # Anything greater than 0 is an error
           channel[:exit_code] = data.read_long
@@ -676,22 +717,14 @@ module Rye
           # This should be the POSIX SIGNAL that ended the process
           channel[:exit_signal] = data.read_long
         end
-        # For long-running commands like top, this will print the output.
-        # It's cool, but we'd also need to enable STDIN to interact with 
-        # command. 
-        #channel.on_data do |ch, data|
-        #  puts "got stdout: #{data}"
-        #  #channel.send_data "something for stdin\n"
-        #end
-        #
-        #channel.on_extended_data do |ch, data|
-        #  #puts "got stdout: #{data}"
-        #  #channel.send_data "something for stdin\n"
-        #end
       end
       
       channel = @rye_ssh.exec(command, &block)
+      
       channel.wait  # block until we get a response
+      channel.request_pty do |ch, success|
+        raise "Could not obtain pty (i.e. an interactive ssh session)" if !success
+      end
       
       channel[:exit_code] = 0 if channel[:exit_code] == nil
       channel[:exit_code] &&= channel[:exit_code].to_i

data/lib/rye/cmd.rb

@@ -43,6 +43,7 @@ module Rye;
     def sed(*args); cmd('sed', args); end
     def awk(*args); cmd('awk', args); end
     def cat(*args); cmd('cat', args); end
+    def tar(*args); cmd('tar', args); end
     
     #def kill(*args); cmd('kill', args); end
     def sudo(*args); cmd('sudo', args); end
@@ -54,6 +55,8 @@ module Rye;
     def echo(*args); cmd('echo', args); end
     def test(*args); cmd('test', args); end
     def mkfs(*args); cmd('mkfs', args); end
+    def gzip(*args); cmd('gzip', args); end
+    def make(*args); cmd('make', args); end
     
     def mount(*args); cmd("mount", args); end
     def sleep(*args); cmd("sleep", args); end
@@ -62,15 +65,20 @@ module Rye;
     def uname(*args); cmd('uname', args); end
     def chmod(*args); cmd('chmod', args); end
     def chown(*args); cmd('chown', args); end
+    def unzip(*args); cmd('unzip', args); end
+    def bzip2(*args); cmd('bzip2', args); end
     
     def umount(*args); cmd("umount", args); end
     def uptime(*args); cmd("uptime", args); end
     def python(*args); cmd('python', args); end
+    def gunzip(*args); cmd('gunzip', args); end
     def useradd(*args); cmd('useradd', args); end
+    def bunzip2(*args); cmd('bunzip2', args); end
     def getconf(*args); cmd('getconf', args); end
     def history(*args); cmd('history', args); end
     def printenv(*args); cmd('printenv', args); end
     def hostname(*args); cmd('hostname', args); end
+    def configure(*args); cmd('./configure', args); end
     
     # Transfer files to a machine via Net::SCP. 
     # * +files+ is an Array of files to upload. The last element is the 
@@ -118,7 +126,7 @@ module Rye;
       self.upload file_content, filepath
     end
     
-    # Does a remote path exist?
+    # Does +path+ from the current working directory?
     def file_exists?(path)
       begin
         ret = self.ls(path)
@@ -129,7 +137,42 @@ module Rye;
       # But on OSX exit code is 1. This is why we look at STDERR. 
       ret.stderr.empty?
     end
-     
+    
+    # Does the calculated digest of +path+ match the known +expected_digest+?
+    # This is useful for verifying downloaded files. 
+    # +digest_type+ must be one of: :md5, :sha1, :sha2
+    def file_verified?(path, expected_digest, digest_type=:md5)
+      return false unless file_exists?(path)
+      raise "Unknown disgest type: #{digest_type}" unless can?("digest_#{digest_type}")
+      digest = self.send("digest_#{digest_type}", path).first
+      info "#{digest_type} (#{path}) = #{digest}"
+      digest.to_s == expected_digest.to_s
+    end
+    
+    # * +files+ An Array of file paths 
+    # Returns an Array of MD5 digests for each of the given files
+    def digest_md5(*files)
+      files.flatten.collect { |file| 
+        File.exists?(file) ? Digest::MD5.hexdigest(File.read(file)) : nil
+      }
+    end
+    
+    # * +files+ An Array of file paths 
+    # Returns an Array of SH1 digests for each of the given files
+    def digest_sha1(*files)
+      files.flatten.collect { |file| 
+        File.exists?(file) ? Digest::SHA1.hexdigest(File.read(file)) : nil
+      }
+    end
+    
+    # * +files+ An Array of file paths 
+    # Returns an Array of SH2 digests for each of the given files
+    def digest_sha2(*files)
+      files.flatten.collect { |file| 
+        File.exists?(file) ? Digest::SHA2.hexdigest(File.read(file)) : nil
+      }
+    end
+    
     # Returns an Array of system commands available over SSH
     def can
       Rye::Cmd.instance_methods

data/rye.gemspec

@@ -1,7 +1,7 @@
 @spec = Gem::Specification.new do |s|
   s.name = "rye"
   s.rubyforge_project = "rye"
-  s.version = "0.7.2"
+  s.version = "0.7.3"
   s.summary = "Rye: Safely run SSH commands on a bunch of machines at the same time (from Ruby)."
   s.description = s.summary
   s.author = "Delano Mandelbaum"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: delano-rye
 version: !ruby/object:Gem::Version 
-  version: 0.7.2
+  version: 0.7.3
 platform: ruby
 authors: 
 - Delano Mandelbaum