delano-rye 0.5.4 → 0.6.0

data/CHANGES.txt

@@ -5,6 +5,27 @@ TODO
 * Fingerprints: ssh-keygen -l -f id_rsa_repos.pub
 
 
+#### 0.6.0 (2009-04-28) #############################
+
+* FIXED: handling of Process::Status ($?) in Rye.shell
+* FIXED: Removed reference to Rudy::Error in bin/rye
+* ADDED: Rye::Box.getenv
+* ADDED: Rye::Box.can? 
+* ADDED: Rye::Box.umask= (a similar work around as cd / [])
+* ADDED: Rye::Box.file_exists?
+* ADDED: Rye::Box.authorize_keys_remote can now authorize for a different user
+* ADDED: Rye::Box.upload and Rye::Box.download
+* ADDED: Rye::SystemInfo.tmpdir
+* CHANGE: Rye::Box.prep_args doesn't treat multicharacter Symbols as 
+command-line options any more (single character ones are still converted)
+* CHANGE: Renamed Rye::Box.add_env to Rye::Box.setenv
+* CHANGE: rm and kill are available in Rye::Cmd by default
+* CHANGE: Rye::Box.authorize_keys renamed Rye::Box.authorize_keys_remote
+* CHANGE: The Rye::Rap object now contains the exit code as an integer for
+Rye.shell and Rye::Box.run_command (SSH) commands.
+* UPDATED: Rdocs and README
+
+
 #### 0.5.4 (2009-04-22) #############################
 
 * FIXED: Sys is now returning environment paths and home path in JRuby.
@@ -19,57 +40,55 @@ TODO
 * ADDED: Rye::Box.connect now rescues HostKeyMismatch exceptions and 
   prompts for a response. 
   
-
 #### 0.5.2 (2009-04-19) #############################
 
 * FIXED: authorize-local command attempted to connect via SSH before authorizing.
 
 #### 0.5.0 (2009-04-18) #############################
 
-* ADDED: Rye::Box.switch_user
-* ADDED: Several new commands to Rye::Cmd
-* ADDED: Rye::Box.authorize_keys_local and "rye authorize-local
 * FIXED: Bug in connect which prevented key-based logins for reconnections
 * FIXED: Method errors in JRuby
 * FIXED: Bug in Rye::Set.add_boxes pushing nils into the list of boxes
+* ADDED: Rye::Box.switch_user
+* ADDED: Several new commands to Rye::Cmd
+* ADDED: Rye::Box.authorize_keys_local and "rye authorize-local
+
 
 #### 0.4.3 (2009-04-14) #############################
 
-* ADDED: Rye::Box.missing_method to handle non existent commands
 * FIXED: All Rye::Cmd command methods accept *args to make calling consistent.
-
+* ADDED: Rye::Box.missing_method to handle non existent commands
 
 #### 0.4.2 (2009-04-13) #############################
 
 * ADDED: More helpful debug output
 * ADDED: hostname command to Rye::Cmd
-* CHANGE: Using OpenSSL's ssh-agent but also let's Net::SSH handle
-  the ssh keys. 
 * ADDED: Rye::Box.connect now supports multiple password attempts if STDIN.tty returns true 
 * ADDED: Rye::Box.interactive_ssh for opening an SSH session to the given box.
+* CHANGE: Using OpenSSL's ssh-agent but also let's Net::SSH handle the ssh keys. 
 
 
 #### 0.4.1 (2009-04-06) #############################
 
-* FIXED: Rye::Box.authorize_keys was not disabling safe mode properly
-* ADDED: "rye authorize" now specifically enforces the auth method order 
+* FIXED: Rye::Box.authorize_keys_remote was not disabling safe mode properly
 * FIXED: Disabled debug mode. 
+* ADDED: "rye authorize" now specifically enforces the auth method order 
 
 
 #### 0.4.0 (2009-04-06) #############################
 
-* ADDED: to_s and inspect methods for cleaner debugging output
-* ADDED: == method for Rye::Box
-* ADDED: exit code and exit signal to Rye::Rap objects
-* ADDED: commands now raise a Rye::CommandError exception 
-  when the command returns an exit code greater than 0. 
-* CHANGED: Box.add_command renamed to Box.run_command
 * FIXED: Box.run_command was parsing arguments incorrectly 
 * FIXED: Box.net_ssh_exec was working on nil stderr
 * FIXED: bin/try handles the new command exceptions
+* ADDED: to_s and inspect methods for cleaner debugging output
+* ADDED: == method for Rye::Box
+* ADDED: exit code and exit signal to Rye::Rap objects
 * ADDED: Command switches can now be sent as Symbols (rbox.ls(:h))
 * ADDED: Rye.host_keys
 * ADDED: bin/rye
+* ADDED: commands now raise a Rye::CommandError exception 
+  when the command returns an exit code greater than 0. 
+* CHANGE: Box.add_command renamed to Box.run_command
 
 
 #### 0.3.2 (2009-04-05) #############################
@@ -81,24 +100,24 @@ TODO
 
 #### 0.3 (2009-04-05) ###############################
 
+* FIXED: Rye::Box wasn't properly adding keypairs to SSH Agent
+* FIXED: Rye::Box.method_missing Symbol/String ambiguity
 * ADDED: Rye::Set supports executing commands parallel 
 * ADDED: Rye::Rap now contains STDERR output from command
-* FIXED: Rye::Box wasn't properly adding keypairs to SSH Agent
-* CHANGED: Moved all SSH key stuff to Rye (used to be done per Box)
 * ADDED: Supports all options provided by Net::SSH#start. This 
-  includes support for password logins and proxies. 
+  includes support for password logins and proxies.
 * ADDED: Safe mode can now be disabled (to allow file globs
   and environment variable access).
 * ADDED: Basic sanity test
-* FIXED: Rye::Box.method_missing Symbol/String ambiguity
 * ADDED: Mucho more rdocs and examples.
+* CHANGE: Moved all SSH key stuff to Rye (used to be done per Box)
+
 
 #### 0.2 (2009-04-04) ###############################
 
 * FIXED: ssh-agent shutdown wasn't deleting the SSH tmp directory
 * ADDED: Now with more rdocs!
 
-
 #### 0.1 (2009-04-03) ###############################
 
 Initial public release

data/README.rdoc

@@ -1,4 +1,4 @@
-= Rye - v0.5
+= Rye - v0.6
 
 Safely run SSH commands on a bunch of machines at the same time (from Ruby).
 
@@ -38,7 +38,7 @@ One of:
     puts rbox.cd('/home/rye').pwd      # => /home/rye
     
     # You can specify environment variables
-    rbox.add_env(:RYE, "Forty Creek")
+    rbox.setenv(:RYE, "Forty Creek")
     rbox.env                           # => ['HOME=/home/rye', 'RYE=Forty Creek', ...]
     
     # The commands method returns an Array of available commands:                        
@@ -123,7 +123,7 @@ One of:
     puts unames.first.box == rbox          # => true
     
     # Envrionment variables can be set the same way as with Rye::Box
-    rset.add_env(:RYE, "Forty Creek")
+    rset.setenv(:RYE, "Forty Creek")
     p rset.env.first.select { |env| env =~ /RYE/ }  # => ["RYE=Forty Creek"]
 
 
@@ -152,20 +152,41 @@ One of:
     # There were no actual error so the exit code should be 0.
     puts rbox.uname('-a 1>&2').exit_code # => 0
 
-== EXAMPLE 6 -- rye
+    
+== EXAMPLE 6 -- FILE TRANSFERS
+
+    rbox = Rye::Box.new("localhost", :info => true)
+
+    dir_upload = "#{Rye.sysinfo.tmpdir}/rye-upload/"
+    dir_download = "#{Rye.sysinfo.tmpdir}/rye-download/"
+    
+    rbox.upload("#{RYE_HOME}/README.rdoc", 
+                "#{RYE_HOME}/LICENSE.txt", dir_upload)
+
+    applejack = StringIO.new("Some in-memory content")
+    rbox.upload(applejack, "#{dir_upload}/applejack.txt")
+
+    p rbox.ls(dir_upload)            # => [README.rdoc, LICENSE.txt, applejack.txt]
+    p rbox.cat("#{dir_upload}/applejack.txt")   # => "Some in-memory content"
+
+    filecontent = StringIO.new
+    rbox.download("#{dir_upload}/applejack.txt", filecontent)
+
+    p filecontent.read
+
+== EXAMPLE 7 -- rye
 
 Rye comes with a command-line utility called <tt>rye</tt>.
 
     # Prints the paths to your private keys
     $ rye keys
-    
+
     # Prints the server host keys (suitable for ~/.ssh/known_hosts)
     $ rye hostkey HOST1 HOST2
-    
+
     # Add your public keys to authorized_keys and authorized_keys2 
     # on a remote machine
     $ rye authorize HOST1 HOST2
-    
 More info:
 
     $ rye -h

data/bin/rye

@@ -48,7 +48,7 @@ command :authorize do |obj|
     
     puts "Authorizing #{rbox.opts[:user]}@#{hostname}"
     rbox = Rye::Box.new(hostname, opts).connect
-    puts "Added public keys for: ", rbox.authorize_keys
+    puts "Added public keys for: ", rbox.authorize_keys_remote
     puts "Now try: " << "ssh #{rbox.opts[:user]}@#{hostname}"
     
   end
@@ -118,8 +118,6 @@ begin
 rescue Drydock::ArgError, Drydock::OptError=> ex
   STDERR.puts ex.message
   STDERR.puts ex.usage
-rescue Rudy::Error => ex
-  STDERR.puts ex.message
 rescue => ex
   STDERR.puts "ERROR (#{ex.class.to_s}): #{ex.message}"
   STDERR.puts ex.backtrace if Drydock.debug?

data/bin/try

@@ -8,7 +8,8 @@
 # Usage: bin/try
 #
 
-$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+RYE_HOME = File.join(File.dirname(__FILE__), '..')
+$:.unshift File.join(RYE_HOME, 'lib')
 
 require 'stringio'
 require 'yaml'
@@ -34,10 +35,9 @@ p rbox.ls(:a, '/')                 # => ['.', '..', 'bin', 'etc', ...]
 puts rbox.pwd                      # => /home/rye
 puts rbox['/usr/bin'].pwd          # => /usr/bin
 puts rbox.pwd                      # => /usr/bin
-puts rbox.cd(Rye.sysinfo.home).pwd # => /home/rye
 
 # You can specify environment variables
-rbox.add_env(:RYE, "Forty Creek")
+rbox.setenv(:RYE, "Forty Creek")
 rbox.env                           # => ['HOME=/home/rye', 'RYE=Forty Creek', ...]
 
 # The commands method returns an Array of available commands:                        
@@ -133,7 +133,7 @@ puts unames.first.box.class            # => Rye::Box
 puts unames.first.box == rbox          # => true
 
 # Envrionment variables can be set the same way as with Rye::Box
-rset.add_env(:RYE, "Forty Creek")
+rset.setenv(:RYE, "Forty Creek")
 p rset.env.first.select { |env| env =~ /RYE/ }  # => ["RYE=Forty Creek"]
 
 
@@ -142,7 +142,7 @@ puts %Q(
 #   EXAMPLE 5 -- ERROR HANDLING
 #)
 
-rbox = Rye::Box.new('localhost', :safe => false)
+rbox = Rye::Box.new('localhost', :safe => false) # Note: safe mode is off
 
 # Rye follows the standard convention of taking exception to a non-zero 
 # exit code by raising a Rye::CommandError. In this case, rye9000.test
@@ -150,8 +150,8 @@ rbox = Rye::Box.new('localhost', :safe => false)
 begin
   rbox.ls('rye.test')
 rescue Rye::CommandError => ex
-  puts ex.exit_code                # => 1
-  puts ex.stderr                   # => ls: rye.test: No such file or directory
+  puts ex.exit_code                  # => 1
+  puts ex.stderr                     # => ls: rye.test: No such file or directory
 end
 
 # The Rye:Rap response objects also give you the STDOUT and STDERR
@@ -162,10 +162,40 @@ puts rbox.uname('-a 1>&2').stdout    # =>
 # It all went to STDERR:
 puts rbox.uname('-a 1>&2').stderr    # => Darwin ryehost 9.6.0 ...
 
-# There were no actual error so the exit code should be 0.
+# There were no actual errors so the exit code should be 0.
 puts rbox.uname('-a 1>&2').exit_code # => 0
 
 
+puts %Q(
+# ------------------------------------------------------------------
+#   EXAMPLE 6 -- FILE TRANSFERS
+#)
+
+dir_upload = "#{Rye.sysinfo.tmpdir}/rye-upload/"
+dir_download = "#{Rye.sysinfo.tmpdir}/rye-download/"
+
+rbox = Rye::Box.new("localhost", :info => false)
+
+# Rye ships without an rm method (for safety!). Here 
+# we add the rm method only to this instance of rbox.
+def rbox.rm(*args); cmd('rm', args); end
+
+rbox.rm(:r, :f, dir_upload) # Silently delete test dirs
+rbox.rm(:r, :f, dir_download)
+
+rbox.upload("#{RYE_HOME}/README.rdoc", 
+            "#{RYE_HOME}/LICENSE.txt", dir_upload)
+
+applejack = StringIO.new("Some in-memory content")
+rbox.upload(applejack, "#{dir_upload}/applejack.txt")
+
+p rbox.ls(dir_upload)            # => [README.rdoc, LICENSE.txt, applejack.txt]
+p rbox.cat("#{dir_upload}/applejack.txt")   # => "Some in-memory content"
+
+filecontent = StringIO.new
+rbox.download("#{dir_upload}/applejack.txt", filecontent)
+              
+p filecontent.read
 
 
 

data/lib/rye.rb

@@ -36,7 +36,7 @@ module Rye
   extend self
 
   unless defined?(SYSINFO)
-    VERSION = 0.5.freeze
+    VERSION = 0.6.freeze
     SYSINFO = SystemInfo.new.freeze
   end
   
@@ -54,6 +54,7 @@ module Rye
   class NotConnected < RuntimeError; end
   class CommandNotFound < RuntimeError; end
   class CommandError < RuntimeError
+    attr_reader :rap
     # * +rap+ a Rye::Rap object
     def initialize(rap)
       @rap = rap
@@ -208,7 +209,7 @@ module Rye
     rap = Rye::Rap.new(self)
     rap.add_stdout(stdout || '')
     rap.add_stderr(stderr || '')
-    rap.exit_code = $?
+    rap.add_exit_code($?)
     rap
   end
   
@@ -224,6 +225,25 @@ module Rye
     @@agent_env
   end
   
+  # Returns +str+ with the leading indentation removed. 
+  # Stolen from http://github.com/mynyml/unindent/ because it was better.
+  def without_indent(str)
+    indent = str.split($/).each {|line| !line.strip.empty? }.map {|line| line.index(/[^\s]/) }.compact.min
+    str.gsub(/^[[:blank:]]{#{indent}}/, '')
+  end
+  
+  # 
+  # Generates a string of random alphanumeric characters.
+  # * +len+ is the length, an Integer. Default: 8
+  # * +safe+ in safe-mode, ambiguous characters are removed (default: true):
+  #       i l o 1 0
+  def strand( len=8, safe=true )
+     chars = ("a".."z").to_a + ("0".."9").to_a
+     chars.delete_if { |v| %w(i l o 1 0).member?(v) } if safe
+     str = ""
+     1.upto(len) { |i| str << chars[rand(chars.size-1)] }
+     str
+  end
   
   private 
   

data/lib/rye/box.rb

@@ -19,22 +19,32 @@ module Rye
   #     rbox.hostname   # => localhost
   #     rbox.uname(:a)  # => Darwin vanya 9.6.0 ...
   #
+  #--
+  # * When anything confusing happens, enable debug in initialize
+  # by passing :debug => STDERR. This will output Rye debug info
+  # as well as Net::SSH info. This is VERY helpful for figuring
+  # out why some command is hanging or otherwise acting weird. 
+  # * If a remote command is hanging, it's probably because a
+  # Net::SSH channel is waiting on_extended_data (a prompt). 
+  #++
   class Box 
     include Rye::Cmd
     
       # An instance of Net::SSH::Connection::Session
     attr_reader :ssh
     
+    attr_reader :info
     attr_reader :debug
     attr_reader :error
     
     attr_accessor :host
-    
     attr_accessor :safe
     attr_accessor :opts
-
+    
       # The most recent value from Box.cd or Box.[]
     attr_reader :current_working_directory
+      # The most recent valud for umask (or 0022)
+    attr_reader :current_umask
     
     # * +host+ The hostname to connect to. The default is localhost.
     # * +opts+ a hash of optional arguments.
@@ -44,14 +54,17 @@ module Rye
     # * :user => the username to connect as. Default: the current user. 
     # * :safe => should Rye be safe? Default: true
     # * :keys => one or more private key file paths (passwordless login)
-    # * :password => the user's password (ignored if there's a valid private key)
+    # * :info => an IO object to print Rye::Box command info to. Default: nil
     # * :debug => an IO object to print Rye::Box debugging info to. Default: nil
     # * :error => an IO object to print Rye::Box errors to. Default: STDERR
+    # * :getenv => pre-fetch +host+ environment variables? (default: true)
+    # * :password => the user's password (ignored if there's a valid private key)
     #
     # NOTE: +opts+ can also contain any parameter supported by 
     # Net::SSH.start that is not already mentioned above.
     #
     def initialize(host='localhost', opts={})
+      @host = host
       
       # These opts are use by Rye::Box and also passed to Net::SSH
       @opts = {
@@ -59,48 +72,46 @@ module Rye
         :safe => true,
         :port => 22,
         :keys => [],
+        :info => nil,
         :debug => nil,
         :error => STDERR,
+        :getenv => true,
       }.merge(opts)
       
-      # See Net::SSH.start
-      @opts[:paranoid] = true unless @opts[:safe] == false
-      
       # Close the SSH session before Ruby exits. This will do nothing
       # if disconnect has already been called explicitly. 
-      at_exit {
-        self.disconnect
-      }
-            
-      @host = host
+      at_exit { self.disconnect }
       
-      @safe = @opts.delete(:safe)
-      @debug = @opts.delete(:debug)
-      @error = @opts.delete(:error)
+      # @opts gets sent to Net::SSH so we need to remove the keys
+      # that are not meant for it. 
+      @safe, @debug = @opts.delete(:safe), @opts.delete(:debug)
+      @info, @error = @opts.delete(:info), @opts.delete(:error)
+      @getenv = {} if @opts.delete(:getenv) # Enable getenv with a hash
       
-      debug @opts.inspect
-            
+      # Just in case someone sends a true value rather than IO object
+      @debug = STDERR if @debug == true
+      @error = STDERR if @error == true
+      @info = STDOUT if @info == true
+      
+      @opts[:logger] = Logger.new(@debug) if @debug # Enable Net::SSH debugging
+      @opts[:paranoid] = true unless @opts[:safe] == false # See Net::SSH.start
+      
+      # Add the given private keys to the keychain that will be used for @host
       add_keys(@opts[:keys])
       
       # We don't want Net::SSH to handle the keypairs. This may change
       # but for we're letting ssh-agent do it. 
       #@opts.delete(:keys)
       
-
-      debug "ssh-agent info: #{Rye.sshagent_info.inspect}"
+      # From: capistrano/lib/capistrano/cli.rb
+      STDOUT.sync = true # so that Net::SSH prompts show up
       
+      debug "ssh-agent info: #{Rye.sshagent_info.inspect}"
+      debug @opts.inspect
+
     end
     
-     
-    # Returns an Array of system commands available over SSH
-    def can
-      Rye::Cmd.instance_methods
-    end
-    alias :commands :can
-    alias :cmds :can
     
-
-      
     # Change the current working directory (sort of). 
     #
     # I haven't been able to wrangle Net::SSH to do my bidding. 
@@ -123,19 +134,33 @@ module Rye
       @current_working_directory = key
       self
     end
-#    alias :cd :'[]'  # fix for jruby
-    def cd(key=nil); 
+    # Like [] except it returns an empty Rye::Rap object to mimick
+    # a regular command method. Call with nil key (or no arg) to 
+    # reset. 
+    def cd(key=nil)
       @current_working_directory = key
+      ret = Rye::Rap.new(self)
+    end
+    
+    # Change the current umask (sort of -- works the same way as cd)
+    # The default umask is 0022
+    def umask=(val='0022')
+      @current_umask = val
       self
     end
-
+    
+    
     # Open an SSH session with +@host+. This called automatically
     # when you the first comamnd is run if it's not already connected.
     # Raises a Rye::NoHost exception if +@host+ is not specified.
     # Will attempt a password login up to 3 times if the initial 
     # authentication fails. 
-    def connect
+    # * +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 @host
+      return if @ssh && !reconnect
       disconnect if @ssh 
       debug "Opening connection to #{@host} as #{@opts[:user]}"
       highline = HighLine.new # Used for password prompt
@@ -146,7 +171,7 @@ module Rye
       rescue Net::SSH::HostKeyMismatch => ex
         STDERR.puts ex.message
         STDERR.puts "NOTE: EC2 instances generate new SSH keys on first boot."
-        print "\a" # Ring the bell
+        print "\a" if @info # Ring the bell
         if highline.ask("Continue? ").strip.match(/\Ay|yes|sure|ya\z/i)
           @opts[:paranoid] = false
           retry
@@ -154,6 +179,7 @@ module Rye
           raise Net::SSH::HostKeyMismatch
         end
       rescue Net::SSH::AuthenticationFailed => ex
+        print "\a" if retried == 0 && @info # Ring the bell once
         retried += 1
         if STDIN.tty? && retried <= 3
           @opts[:password] = highline.ask("Password: ") { |q| q.echo = '' }
@@ -171,20 +197,11 @@ module Rye
       # the next connection (if we switch_user is called for example).
       @opts.delete :auth_methods if @opts.has_key?(:auth_methods)
       
-      @ssh.is_a?(Net::SSH::Connection::Session) && !@ssh.closed?
       self
     end
     
-    # Close the SSH session  with +@host+. This is called 
-    # automatically at exit if the connection is open. 
-    def disconnect
-      return unless @ssh && !@ssh.closed?
-      @ssh.loop(0.1) { @ssh.busy? }
-      debug "Closing connection to #{@ssh.host}"
-      @ssh.close
-    end
-    
-    # Reconnect as another user
+    # Reconnect as another user. This is different from su=
+    # which executes subsequent commands via +su -c COMMAND USER+. 
     # * +newuser+ The username to reconnect as 
     #
     # NOTE: if there is an open connection, it's disconnected
@@ -197,6 +214,17 @@ module Rye
       connect
     end
     
+    
+    # Close the SSH session  with +@host+. This is called 
+    # automatically at exit if the connection is open. 
+    def disconnect
+      return unless @ssh && !@ssh.closed?
+      @ssh.loop(0.1) { @ssh.busy? }
+      debug "Closing connection to #{@ssh.host}"
+      @ssh.close
+    end
+    
+    
     # Open an interactive SSH session. This only works if STDIN.tty?
     # returns true. Otherwise it returns the SSH command that would 
     # have been run. This requires the SSH command-line executable (ssh).
@@ -229,12 +257,14 @@ module Rye
     
     # Add an environment variable. +n+ and +v+ are the name and value.
     # Returns the instance of Rye::Box
-    def add_env(n, v)
-      debug "Added env: #{n}=#{v}"
+    def setenv(n, v)
+      debug "Adding env: #{n}=#{v}"
+      debug "prev value: #{@getenv[n]}"
+      @getenv[n] = v
       (@current_environment_variables ||= {})[n] = v
       self
     end
-    alias :add_environment_variable :add_env
+    alias :add_env :setenv  # deprecated?
     
     def user
       (@opts || {})[:user]
@@ -251,9 +281,10 @@ module Rye
     end
     
     def inspect
-      %q{#<%s:%s cwd=%s env=%s safe=%s opts=%s>} % 
+      %q{#<%s:%s cwd=%s umask=%s env=%s safe=%s opts=%s>} % 
       [self.class.to_s, self.host, 
-       @current_working_directory, (@current_environment_variables || '').inspect,
+       @current_working_directory, @current_umask,
+       (@current_environment_variables || '').inspect,
        self.safe, self.opts.inspect]
     end
     
@@ -269,34 +300,89 @@ module Rye
       Rye.remote_host_keys(@host)
     end
     
+    # Uses the output of "useradd -D" to determine the default home
+    # directory. This returns a GUESS rather than the a user's real
+    # home directory. Currently used only by authorize_keys_remote.
+    def guess_user_home(other_user=nil)
+      # Some junk to determine where user home directories are by default.
+      # We're relying on the command "useradd -D" so this may not work on
+      # different Linuxen and definitely won't work on Windows.
+      # This code will be abstracted out once I find a decent home for it.
+      # /etc/default/useradd, HOME=/home OR useradd -D
+      # /etc/adduser.config, DHOME=/home OR ??
+      user_defaults = {}
+      raw = self.useradd(:D) rescue ["HOME=/home"]
+      raw.each do |nv|
+        n, v = nv.scan(/\A([\w_-]+?)=(.+)\z/).flatten
+        user_defaults[n] = v
+      end
+      "#{user_defaults['HOME']}/#{other_user}"
+    end
+    
     # Copy the local public keys (as specified by Rye.keys) to 
     # this box into ~/.ssh/authorized_keys and ~/.ssh/authorized_keys2. 
-    # Returns an Array of the private keys files used to generate the public keys.
-    #
-    # NOTE: authorize_keys disables safe-mode for this box while it runs
+    # Returns a Rye::Rap object. The private keys files used to generate 
+    # the public keys are contained in stdout.
+    # Raises a Rye::ComandError if the home directory doesn't exit. 
+    # NOTE: authorize_keys_remote disables safe-mode for this box while it runs
     # which will hit you funky style if your using a single instance
     # of Rye::Box in a multithreaded situation. 
     #
-    def authorize_keys
+    def authorize_keys_remote(other_user=nil)
+      this_user = other_user || @user
       added_keys = []
-      @safe= false
-      Rye.keys.each do |key|
-        path = key[2]
-        debug "# Public key for #{path}"
-        k = Rye::Key.from_file(path).public_key.to_ssh2
-        self.mkdir(:p, :m, '700', '$HOME/.ssh') # Silently create dir if it doesn't exist
-        self.echo("'#{k}' >> $HOME/.ssh/authorized_keys")
-        self.echo("'#{k}' >> $HOME/.ssh/authorized_keys2")
-        self.chmod('-R', '0600', '$HOME/.ssh/authorized_keys*')
-        added_keys << path
+      rap = Rye::Rap.new(self)
+      
+      # The homedir path is important b/c this is where we're going to 
+      # look for the .ssh directory. That's where auth love is stored.
+      homedir = self.guess_user_home(this_user)
+      
+      unless self.file_exists?(homedir)
+        rap.add_exit_code(1)
+        rap.add_stderr("Path does not exist: #{homedir}")
+        raise Rye::CommandError.new(rap)
       end
-      @safe = true
-      added_keys
+      
+      # Let's go into the user's home directory that we now know exists.
+      self.cd homedir
+      
+      files = ['.ssh/authorized_keys', '.ssh/authorized_keys2']
+      files.each do |akey_path|
+        if self.file_exists?(akey_path)
+          # TODO: Make Rye::Cmd.incremental_backup
+          self.cp(akey_path, "#{akey_path}-previous")
+          authorized_keys = self.download("#{homedir}/#{akey_path}")
+        end
+        authorized_keys ||= StringIO.new
+        
+        Rye.keys.each do |key|
+          path = key[2]
+          info "# Adding public key for #{path}"
+          k = Rye::Key.from_file(path).public_key.to_ssh2
+          authorized_keys.puts k
+        end
+        
+        # Remove duplicate authorized keys
+        authorized_keys.rewind
+        uniqlines = authorized_keys.readlines.uniq.join
+        authorized_keys = StringIO.new(uniqlines)
+        # We need to rewind so that all of the StringIO object is uploaded
+        authorized_keys.rewind
+        
+        self.mkdir(:p, :m, '700', File.dirname(akey_path))
+        self.upload(authorized_keys, "#{homedir}/#{akey_path}")
+        self.chmod('0600', akey_path)
+        self.chown(:R, this_user.to_s, File.dirname(akey_path))
+      end
+      
+      
+      rap.add_exit_code(0)
+      rap
     end
     
     # Authorize the current user to login to the local machine via
     # SSH without a password. This is the same functionality as
-    # authorize_keys except run with local shell commands. 
+    # authorize_keys_remote except run with local shell commands. 
     def authorize_keys_local
       added_keys = []
       Rye.keys.each do |key|
@@ -323,10 +409,10 @@ module Rye
     
   private
       
-    
     def debug(msg="unknown debug msg"); @debug.puts msg if @debug; end
     def error(msg="unknown error msg"); @error.puts msg if @error; end
-
+    def pinfo(msg="unknown info msg"); @info.print msg if @info; end
+    def info(msg="unknown info msg"); @info.puts msg if @info; end
     
     # Add the current environment variables to the beginning of +cmd+
     def prepend_env(cmd)
@@ -348,7 +434,7 @@ module Rye
     # will be thoroughly escaped and passed to the command.
     #
     #     rbox = Rye::Box.new
-    #     rbox.ls '-l', 'arg1', 'arg2'
+    #     rbox.ls :l, 'arg1', 'arg2'
     #
     # is equivalent to
     #
@@ -367,17 +453,30 @@ module Rye
 
       cmd_clean = Rye.escape(@safe, cmd, args)
       cmd_clean = prepend_env(cmd_clean)
+      
+      # Add the current working directory before the command if supplied. 
+      # The command will otherwise run in the user's home directory.
       if @current_working_directory
         cwd = Rye.escape(@safe, 'cd', @current_working_directory)
         cmd_clean = [cwd, cmd_clean].join(' && ')
       end
       
+      # ditto (same explanation as cwd)
+      if @current_umask
+        cwd = Rye.escape(@safe, 'umask', @current_umask)
+        cmd_clean = [cwd, cmd_clean].join(' && ')
+      end
+      
+      
+      info "COMMAND: #{cmd_clean}"
       debug "Executing: %s" % cmd_clean
-      stdout, stderr, ecode, esignal = net_ssh_exec! cmd_clean
+      
+      stdout, stderr, ecode, esignal = net_ssh_exec!(cmd_clean)
+      
       rap = Rye::Rap.new(self)
       rap.add_stdout(stdout || '')
       rap.add_stderr(stderr || '')
-      rap.exit_code = ecode
+      rap.add_exit_code(ecode)
       rap.exit_signal = esignal
       rap.cmd = cmd
       
@@ -387,10 +486,10 @@ module Rye
     end
     alias :cmd :run_command
     
-
-    
     # Takes a list of arguments appropriate for run_command or
-    # preview_command and returns: [cmd, args]
+    # preview_command and returns: [cmd, args]. 
+    # Single character symbols with be converted to command line
+    # switches. Example:   +:l+ becomes +-l+
     def prep_args(*args)
       args = args.flatten.compact
       args = args.first.to_s.split(/\s+/) if args.size == 1
@@ -398,8 +497,9 @@ module Rye
       
       # Symbols to switches. :l -> -l, :help -> --help
       args.collect! do |a|
-        a = "-#{a}" if a.is_a?(Symbol) && a.to_s.size == 1
-        a = "--#{a}" if a.is_a?(Symbol)
+        if a.is_a?(Symbol)
+          a = (a.to_s.size == 1) ? "-#{a}" : a.to_s
+        end
         a
       end
       [cmd, args]
@@ -408,9 +508,11 @@ module Rye
     # Executes +command+ via SSH
     # Returns an Array with 4 elements: [stdout, stderr, exit code, exit signal]
     def net_ssh_exec!(command)
+      
       block ||= Proc.new do |channel, type, data|
         channel[:stdout] ||= ""
         channel[:stderr] ||= ""
+        channel[:exit_code] ||= -1
         channel[:stdout] << data if type == :stdout
         channel[:stderr] << data if type == :stderr
         channel.on_request("exit-status") do |ch, data|
@@ -426,14 +528,19 @@ module Rye
         # command. 
         #channel.on_data do |ch, data|
         #  puts "got stdout: #{data}"
-        #  channel.send_data "something for stdin\n"
+        #  #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 = @ssh.exec(command, &block)
       channel.wait  # block until we get a response
       
-      channel[:exit_code] ||= 0
+      channel[:exit_code] = 0 if channel[:exit_code] == nil
       channel[:exit_code] &&= channel[:exit_code].to_i
       
       channel[:stderr].gsub!(/bash: line \d+:\s+/, '') if channel[:stderr]
@@ -442,6 +549,81 @@ module Rye
     end
     
     
+    # * +direction+ is one of :upload, :download
+    # * +files+ is an Array of file paths, the content is direction specific.
+    # For downloads, +files+ is a list of files to download. The last element
+    # must be the local directory to download to. If downloading a single file
+    # the last element can be a file path. The target can also be a StringIO.
+    # For uploads, +files+ is a list of files to upload. The last element is
+    # the directory to upload to. If uploading a single file, the last element
+    # can be a file path. The list of files can also include StringIO objects.
+    # For both uploads and downloads, the target directory will be created if
+    # it does not exist, but only when multiple files are being transferred. 
+    # This method will fail early if there are obvious problems with the input
+    # parameters. An exception is raised and no files are transferred. 
+    # Uploads always return nil. Downloads return nil or a StringIO object if
+    # one is specified for the target. 
+    def net_scp_transfer!(direction, *files)
+      direction ||= ''
+      unless [:upload, :download].member?(direction.to_sym)
+        raise "Must be one of: upload, download" 
+      end
+      
+      if @current_working_directory
+        info "CWD (#{@current_working_directory}) not used"
+      end
+      
+      files = [files].flatten.compact || []
+
+      # We allow a single file to be downloaded into a StringIO object
+      # but only when no target has been specified. 
+      if direction == :download && files.size == 1
+        debug "Created StringIO for download"
+        other = StringIO.new
+      else
+        other = files.pop
+      end
+      
+      if direction == :upload && other.is_a?(StringIO)
+        raise "Cannot upload to a StringIO object"
+      end
+              
+      # Fail early. We check the 
+      files.each do |file|
+        if file.is_a?(StringIO)
+          raise "Cannot download a StringIO object" if direction == :download
+          raise "StringIO object not opened for reading" if file.closed_read?
+          # If a StringIO object is at end of file, SCP will hang. (TODO: SCP)
+          file.rewind if file.eof?
+        end
+      end
+      
+      debug "#{direction.to_s.upcase} TO: #{other}"
+      debug "FILES: " << files.join(', ')
+      
+      # Make sure the remote directory exists. We can do this only when
+      # there's more than one file because "other" could be a file name
+      if files.size > 1 && !other.is_a?(StringIO)
+        debug "CREATING TARGET DIRECTORY: #{other}"
+        self.mkdir(:p, other) unless self.file_exists?(other)
+      end
+      
+      Net::SCP.start(@host, @opts[:user], @opts || {}) do |scp|
+        transfers = []
+        files.each do |file|
+          debug file.to_s
+          transfers << scp.send(direction, file, other)  do |ch, n, s, t|
+            pinfo "#{n}: #{s}/#{t}b\r"  # update line: "file: sent/total"
+            @info.flush if @info        # make sure every line is printed
+          end
+        end
+        transfers.each { |t| t.wait }   # Run file transfers in parallel
+        info $/
+      end
+      
+      other.is_a?(StringIO) ? other : nil
+    end
+    
 
   end
 end

data/lib/rye/cmd.rb

@@ -18,6 +18,12 @@ module Rye;
   #     rbox.special        # => "special on somehost"
   #
   module Cmd
+    
+    #--
+    # TODO: Clean this trite mess up!
+    #++
+    
+    def cd(*args); cmd('cd', args); end
     def wc(*args); cmd('wc', args); end
     def cp(*args); cmd("cp", args); end
     def mv(*args); cmd("mv", args); end
@@ -28,8 +34,8 @@ module Rye;
     def df(*args); cmd('df', args); end
     def du(*args); cmd('du', args); end
     
-    def env(*args); cmd "env"; end
-    def pwd(*args); cmd "pwd"; end
+    def env; cmd "env"; end
+    def pwd(*args); cmd "pwd", args; end
     def svn(*args); cmd('svn', args); end
     def cvs(*args); cmd('cvs', args); end
     def git(*args); cmd('git', args); end
@@ -49,40 +55,100 @@ module Rye;
     def mkfs(*args); cmd('mkfs', args); end
     
     def mount(*args); cmd("mount", args); end
-    def sleep(seconds=1); cmd("sleep", seconds); end
+    def sleep(*args); cmd("sleep", args); end
     def mkdir(*args); cmd('mkdir', args); end
     def touch(*args); cmd('touch', args); end
     def uname(*args); cmd('uname', args); end
     def chmod(*args); cmd('chmod', args); end
+    def chown(*args); cmd('chown', args); end
     
     def umount(*args); cmd("umount", args); end
     def uptime(*args); cmd("uptime", args); end
     def python(*args); cmd('python', args); end
+    def useradd(*args); cmd('useradd', 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 copy_to(*boxes)
-    #    p boxes
+    # Transfer files to a machine via Net::SCP. 
+    # * +files+ is an Array of files to upload. The last element is the 
+    # directory to upload to. If uploading a single file, the last element
+    # can be a file path. The list of files can also include StringIO objects.
+    # The target directory will be created if it does not exist, but only 
+    # when multiple files are being transferred. 
+    # This method will fail early if there are obvious problems with the input
+    # parameters. An exception is raised and no files are transferred. 
+    # Always return nil.
     #
-    #    @scp = Net::SCP.start(@host, @opts[:user], @opts || {}) 
-    #    #@ssh.is_a?(Net::SSH::Connection::Session) && !@ssh.closed?
-    #     p @scp
-    #  end
-  
-  
-    #def copy_to(*args)
-    #  args = [args].flatten.compact || []
-    #  other = args.pop
-    #  p other
-    #end
+    # NOTE: Changes to current working directory with +cd+ or +[]+ are ignored.
+    def upload(*files); net_scp_transfer!(:upload, *files); end
+
+    # Transfer files from a machine via Net::SCP. 
+    # * +files+ is an Array of files to download. The last element must be the 
+    # local directory to download to. If downloading a single file the last 
+    # element can be a file path. The target can also be a StringIO object.
+    # The target directory will be created if it does not exist, but only 
+    # when multiple files are being transferred. 
+    # This method will fail early if there are obvious problems with the input
+    # parameters. An exception is raised and no files are transferred.
+    # Return nil or a StringIO object, if specified as the target.
+    #
+    # NOTE: Changes to current working directory with +cd+ or +[]+ are ignored.
+    def download(*files); net_scp_transfer!(:download, *files); end
+    
+    # Does a remote path exist?
+    def file_exists?(path)
+      begin
+        ret = self.ls(path)
+      rescue Rye::CommandError => ex
+        ret = ex.rap
+      end
+      # "ls" returns a 0 exit code regardless of success in Linux
+      # But on OSX exit code is 1. This is why we look at STDERR. 
+      ret.stderr.empty?
+    end
+    
+    # Returns the hash containing the parsed output of "env" on the 
+    # remote machine. If the initialize option +:getenv+ was set to 
+    # false, this will return an empty hash. 
+    # This is a lazy loaded method so it fetches the remote envvars
+    # the first time this method is called. 
+    #
+    #      puts rbox.getenv['HOME']    # => "/home/gloria" (remote)
+    #
+    def getenv
+      if @getenv && @getenv.empty? && self.can?(:env)
+        env = self.env rescue []
+        env.each do |nv| 
+          # Parse "GLORIA_HOME=/gloria/lives/here" into a name/value
+          # pair. The regexp ensures we split only at the 1st = sign
+          n, v = nv.scan(/\A([\w_-]+?)=(.+)\z/).flatten
+          @getenv[n] = v
+        end
+      end
+      @getenv
+    end
+     
+    # Returns an Array of system commands available over SSH
+    def can
+      Rye::Cmd.instance_methods
+    end
+    alias :commands :can
+    alias :cmds :can
     
-    def exists?
-      cmd("uptime");
+    def can?(meth)
+      self.can.member?(RUBY_VERSION =~ /1.9/ ? meth.to_sym : meth.to_s)
     end
+    alias :command? :can?
+    alias :cmd? :can?
+    
+    
     
-    # Consider Rye.sysinfo.os == :unix
+    #--
+    # * Consider a lock-down mode using method_added
+    # * Consider Rye.sysinfo.os == :unix
+    #++
   end
 
 end

data/lib/rye/rap.rb

@@ -20,7 +20,9 @@ module Rye;
     
      # An array containing any STDERR output 
     attr_reader :stderr
-    attr_accessor :exit_code
+    attr_reader :exit_code
+      # Only populated when calling via Rye::Shell 
+    attr_reader :pid 
     attr_accessor :exit_signal
     
       # The command that was executed. 
@@ -30,6 +32,8 @@ module Rye;
     # * +args+ anything that can sent to Array#new
     def initialize(obj, *args)
       @obj = obj
+      @exit_code = 0
+      @stderr = []
       super *args
     end
     
@@ -65,12 +69,29 @@ module Rye;
       self.flatten!
     end
     
+    # Parse the exit code. 
+    # * +code+ an exit code string or integer or Process::Status object
+    # For example, when running a command via Rye.shell, this method 
+    # is send $? which is Process::Status object. Via Rye::Box.run_command
+    # it's just an exit code returned by Net::SSH. 
+    # Returns the exit code as an Integer. 
+    def add_exit_code(code)
+      code = -1 unless code
+      if code.is_a?(Process::Status)
+        @exit_code, @pid = code.exitstatus.to_i, code.pid
+      else
+        @exit_code = code.to_i
+      end
+      @exit_code
+    end
+    def code; @exit_code; end
+    
     # Returns the first element if there it's the only
     # one, otherwise the value of Array#to_s
     def to_s
       return self.first if self.size == 1
       return "" if self.size == 0
-      super
+      self
     end
     
     # NOTE: This is broken!

data/lib/rye/set.rb

@@ -68,11 +68,11 @@ module Rye
     
     # Add an environment variable. +n+ and +v+ are the name and value.
     # Returns the instance of Rye::Set
-    def add_env(n, v)
-      run_command(:add_env, n, v)
+    def setenv(n, v)
+      run_command(:setenv, n, v)
       self
     end
-    alias :add_environment_variable :add_env
+    alias :setenvironment_variable :setenv
     
     # See Rye.keys
     def keys

data/lib/sys.rb

@@ -274,6 +274,19 @@ class SystemInfo #:nodoc:all
     end
   end
   
+  def tmpdir
+    if @os == :unix
+      (ENV['TMPDIR'] || '/tmp')
+    elsif @os == :win32
+      (ENV['TMPDIR'] || 'C:\\temp')
+    elsif @os == :java
+      default = @impl == :windows ? 'C:\\temp' : '/tmp'
+      (ENV['TMPDIR'] || default)
+    else
+      raise "paths not implemented for: #{@os}"
+    end
+  end
+  
   # Print friendly system information. 
   def to_s
     sprintf("Hostname: %s#{$/}IP Address: %s#{$/}System: %s#{$/}Uptime: %.2f (hours)#{$/}Ruby: #{ruby.join('.')}", 

data/rye.gemspec

@@ -1,7 +1,7 @@
 @spec = Gem::Specification.new do |s|
   s.name = "rye"
   s.rubyforge_project = "rye"
-  s.version = "0.5.4"
+  s.version = "0.6.0"
   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"
@@ -15,6 +15,11 @@
   s.add_dependency 'highline'
   s.add_dependency 'drydock'
   
+  # = EXECUTABLES =
+  # The list of executables in your project (if any). Don't include the path, 
+  # just the base filename.
+  s.executables = %w[rye]
+  
   # = MANIFEST =
   # The complete list of files to be included in the release. When GitHub packages your gem, 
   # it doesn't allow you to run any command that accesses the filesystem. You will get an
@@ -44,15 +49,12 @@
   tst/10-key2
   tst/10-key2.pub
   tst/10_keys_test.rb
-  tst/50_rye_test.rb
+  tst/50_rset_test.rb
+  tst/60-file.mp3
+  tst/60_rbox_transfer_test.rb
+  tst/70_rbox_env_test.rb
   )
   
-  # = EXECUTABLES =
-  # The list of executables in your project (if any). Don't include the path, 
-  # just the base filename.
-  s.executables = %w[rye]
-  
-  
   s.extra_rdoc_files = %w[README.rdoc LICENSE.txt]
   s.has_rdoc = true
   s.rdoc_options = ["--line-numbers", "--title", s.summary, "--main", "README.rdoc"]

data/tst/{50_rye_test.rb → 50_rset_test.rb}

@@ -1,7 +1,7 @@
 #!/usr/bin/ruby
 
 # 
-# Usage: test/10_rye_test.rb
+# Usage: test/50_rye_test.rb
 #
 
 $:.unshift File.join(File.dirname(__FILE__), '..', 'lib')

data/tst/60_rbox_transfer_test.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/ruby
+
+# 
+# Usage: test/60_rbox_upload_test.rb
+#
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require "rubygems"
+require "stringio"
+require "yaml"
+require "rye"
+
+tmpdir = Rye.sysinfo.tmpdir
+
+rbox = Rye::Box.new("localhost", :info => true)
+def rbox.rm(*args); cmd('rm', args); end
+rbox.rm(:r, :f, "#{tmpdir}/rye-upload") # Silently delete test dir
+
+# /tmp/rye-upload will be created if it doesn't exist
+rbox.upload("README.rdoc", "LICENSE.txt", "#{tmpdir}/rye-upload")
+
+# A single file can be renamed
+rbox.upload("README.rdoc", "#{tmpdir}/rye-upload/README-renamed")
+
+# StringIO objects can be sent as files
+applejack = StringIO.new
+applejack.puts "Delano: What's happening Applejack?"
+applejack.puts "Applejack: Just trying to get by."
+rbox.upload(applejack, "#{tmpdir}/rye-upload/applejack")
+
+rbox.upload("tst/60-file.mp3", "#{tmpdir}/rye-upload")  # demonstrates
+rbox.upload("tst/60-file.mp3", "#{tmpdir}/rye-upload")  # progress
+rbox.upload("tst/60-file.mp3", "#{tmpdir}/rye-upload")  # bar
+
+puts "Content of /tmp/rye-upload"
+puts rbox.ls(:l, "#{tmpdir}/rye-upload")
+
+rbox.download("#{tmpdir}/rye-upload/README.rdoc", 
+              "#{tmpdir}/rye-upload/README-renamed", "#{tmpdir}/rye-download")
+
+# You can't download a StringIO object. This raises an exception:
+#rbox.download(applejack, "#{tmpdir}/rye-download/applejack") 
+# But you can download _to_ a StringIO object
+applejack = StringIO.new
+rbox.download("#{tmpdir}/rye-upload/applejack", applejack)
+
+puts $/, "Content of /tmp/rye-download"
+puts rbox.ls(:l, "#{tmpdir}/rye-download")
+
+puts $/, "Content of applejack StringIO object"
+applejack.rewind
+puts applejack.read

data/tst/70_rbox_env_test.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/ruby
+
+# 
+# Usage: test/70_rbox_env_test.rb
+#
+
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require "rubygems"
+require "stringio"
+require "yaml"
+require "rye"
+
+tmpdir = Rye.sysinfo.tmpdir
+
+rbox = Rye::Box.new("localhost", :info => true)
+
+puts rbox.getenv['HOME']  # slight delay while vars are fetched
+puts rbox.getenv['HOME']  # returned from memory

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: delano-rye
 version: !ruby/object:Gem::Version 
-  version: 0.5.4
+  version: 0.6.0
 platform: ruby
 authors: 
 - Delano Mandelbaum
@@ -84,7 +84,10 @@ files:
 - tst/10-key2
 - tst/10-key2.pub
 - tst/10_keys_test.rb
-- tst/50_rye_test.rb
+- tst/50_rset_test.rb
+- tst/60-file.mp3
+- tst/60_rbox_transfer_test.rb
+- tst/70_rbox_env_test.rb
 has_rdoc: true
 homepage: http://solutious.com/
 post_install_message: