rye 0.8.0 → 0.8.1

data/CHANGES.txt

@@ -6,6 +6,14 @@ TODO
 * Fingerprints: ssh-keygen -l -f id_rsa_repos.pub
 * Add S3 support for Rye::Box.upload / download
 
+#### 0.8.1 (2009-06-22) #############################
+
+* FIXED: file_upload now handles globs like a champ
+* FIXED: Handling of relative paths in Rye::Box#cd and Rye::Box#[]
+* ADDED: file_upload now assumes uploading to home directory when only 1 arg
+* ADDED: Rudyfile for remote 'clean-machine' tests
+* CHANGE: guess_user_home, ostype, and getenv now run quietly
+
 
 #### 0.8.0 (2009-06-21) #############################
 

data/Rudyfile

@@ -0,0 +1,135 @@
+# = Rudy configuration
+#
+
+# ----------------------------------------------------------- DEFAULTS --------
+# These values are used as defaults for their respective global settings. All
+# non-boolean values are expected to be Symbols. 
+#
+defaults do
+  zone :'eu-west-1b'
+  environment :rye
+  color true                        # Terminal colors? true/false
+  yes false                         # Auto-confirm? true/false
+end
+
+# ---------------------------------------------------------  MACHINES  --------
+# The machines block describes the 'physical' characteristics of your machines. 
+machines do
+  
+  zone :'us-east-1b' do
+    ami 'ami-e348af8a'               # Alestic Debian 5.0, 32-bit (US)
+    bucket 'rudy-ami-us'
+  end
+  zone :'eu-west-1b' do
+    ami 'ami-1dbd9569'               # rudy-ami-eu/debian-5.0-32-ruby-r1
+    bucket 'rudy-ami-eu'
+  end
+  
+  hostname :rudy                     # One of: :default, :rudy, 'your-name'
+
+  env :rye do
+    user :root                       # User to connect as
+    size 'm1.small'                  # EC2 machine type for all machines
+  end  
+  
+end
+
+
+# ----------------------------------------------------------- COMMANDS --------
+# The commands block defines shell commands that can be used in routines. The
+# ones defined here are added to the default list defined by Rye::Cmd (Rudy 
+# executes all SSH commands via Rye). 
+#
+# Usage: 
+#
+# allow COMMAND-NAME
+# allow COMMAND-NAME, '/path/2/COMMAND'
+# allow COMMAND-NAME, '/path/2/COMMAND', 'default argument', 'another arg'
+#
+commands do
+  allow :apt_get, "apt-get", :y, :q
+  allow :gem18_install, "/usr/bin/gem1.8", "install", :n, '/usr/bin', :y, :V, "--no-rdoc", "--no-ri"
+  allow :gem18_sources, "/usr/bin/gem1.8", "sources"
+  allow :gem19_install, "/usr/local/bin/gem", "install", :n, '/usr/bin', :y, :V, "--no-rdoc", "--no-ri"
+  allow :gem19_sources, "/usr/local/bin/gem", "sources"
+  allow :update_rubygems
+  allow :ruby18, "/usr/bin/ruby1.8"
+  allow :ruby19, "/usr/local/bin/ruby"
+  allow :ssh_keygen, 'ssh-keygen'
+  allow :rm
+end
+
+# ----------------------------------------------------------- ROUTINES --------
+# The routines block describes the repeatable processes for each machine group.
+# To run a routine, specify its name on the command-line: rudy startup
+routines do
+  
+  env :rye do
+    startup do
+      after :installdeps, :authorize
+      after :runtest
+    end
+  end
+  
+  runtest do
+    remote :root do 
+      ruby18 :r, 'rubygems', 'rye/bin/try' 
+      ruby19 'rye/bin/try'
+    end
+  end
+  
+  authorize do
+    remote :root do
+      rm :f, '/root/.ssh/id_rsa'
+      ssh_keygen :q, :f, '/root/.ssh/id_rsa', :N, ''
+      rye 'authorize_local'
+    end
+  end
+  
+  installdeps do
+    local do
+      rake 'package'
+    end
+    remote :root do
+      gem18_install "rye", "delano-rye"
+      gem19_install "rye", 'delano-rye'
+      disable_safe_mode
+      rm :r, :f, 'rye*'
+      file_upload 'pkg/rye-*gz'
+      tar :z, :x, :f, 'rye-*gz'
+      rm 'rye-*gz'
+      mv 'rye-*', 'rye'
+      cd 'rye'
+    end
+  end
+  
+  # NOTE: sysupdate only needs to be run for the bare instances. 
+  sysupdate do
+    remote :root do                  
+      apt_get "update"               
+      apt_get "install", "build-essential", "git-core"
+      apt_get "install", "libssl-dev", "libreadline5-dev", "zlib1g-dev"
+      apt_get "install", "ruby1.8-dev", "rubygems"
+      gem18_install 'rubygems-update' # for 1.8
+      update_rubygems                 # for 1.8
+      gem18_sources :a, "http://gems.github.com"
+    end
+    after :install_ruby19
+  end
+  
+  install_ruby19 do
+    remote :root do
+      wget :q, 'ftp://ftp.ruby-lang.org/pub/ruby/1.9/ruby-1.9.1-p129.tar.gz'
+      tar :z, :x, :f, 'ruby-1.9.1-p129.tar.gz'
+      cd 'ruby-1.9.1-p129'
+      configure
+      make
+      make 'install'
+      apt_get "install", "rubygems1.9"
+      gem19_sources :a, "http://gems.github.com"
+    end
+  end
+  
+end
+
+

data/bin/try

@@ -0,0 +1,202 @@
+#!/usr/bin/ruby
+
+# Rye -- A working example
+#
+# If your reading this via the rdocs you won't be able to see the code
+# See: http://github.com/delano/rye/blob/master/bin/try
+#
+# Usage: bin/try
+#
+
+RYE_HOME = File.join(File.dirname(__FILE__), '..')
+$:.unshift File.join(RYE_HOME, 'lib')
+%w{net-ssh sysinfo storable drydock}.each { |dir| $:.unshift File.join(File.dirname(__FILE__), '..', '..', dir, 'lib') }
+
+require 'stringio'
+require 'yaml'
+require 'rye'
+
+
+puts %Q(
+# ------------------------------------------------------------------
+#   EXAMPLE 1 -- Basic Usage
+#)
+
+rbox = Rye::Box.new('localhost')
+
+# Commands are run as methods on the Rye::Box object
+puts rbox.uptime                   # => 11:02  up 16:01, 3 users
+
+# The response value for all commands is a Rye::Rap object. The rap is a
+# subclass of Array so you can treat it as an Array, but it can also act 
+# like a String if there's only one element. 
+p rbox.ls(:a, '/')                 # => ['.', '..', 'bin', 'etc', ...]
+
+# You can change directories
+puts rbox.pwd                      # => /home/rye
+puts rbox['/usr/bin'].pwd          # => /usr/bin
+puts rbox.pwd                      # => /usr/bin
+
+# You can specify environment variables
+rbox.setenv(:RYE, "Forty Creek")
+rbox.env                           # => ['HOME=/home/rye', 'RYE=Forty Creek', ...]
+
+# The commands method returns an Array of available commands:                        
+puts rbox.commands.join(', ')      # => pwd, touch, echo, wc, ...
+
+# When you're done you can disconnect explicitly. 
+# (Although Rye does this automatically at exit.)
+rbox.disconnect
+
+
+puts %Q(
+# ------------------------------------------------------------------
+#   EXAMPLE 2 -- Disabling Safe-Mode
+#)
+
+rbox_safe = Rye::Box.new('localhost')
+rbox_wild = Rye::Box.new('localhost', :safe => false)
+
+# Safe-mode is enabled by default. In safe-mode, all command 
+# arguments are thoroughly escaped. This prevents access to
+# environment variables and file globs (among other things).
+p rbox_safe.echo('$HOME')                                    # => "$HOME"
+p rbox_safe['/etc'].ls('host*')  rescue Rye::CommandError    # Doesn't exist
+p rbox_safe.ls('-l | wc -l')     rescue Rye::CommandError    # => '|' is not a valid ls arg
+
+# Here's the same commands with safe-mode disabled:
+p rbox_wild.echo('$HOME')                   # => "/home/rye"
+p rbox_wild['/etc'].ls('host*')             # => ["hostconfig", "hosts"]
+p rbox_wild.ls('-l | wc -l')                # => 110
+p rbox_wild.echo('$HOME > /tmp/rye-home')   # => 
+p rbox_wild.cat('/tmp/rye-home')            # => "/home/rye"
+
+
+
+puts %Q(
+# ------------------------------------------------------------------
+#   EXAMPLE 3 -- Custom Commands
+#)
+
+rbox = Rye::Box.new('localhost')
+rbox.add_keys('/private/key/path')   # Specify additional private keys
+
+# There's currently no rye900 command
+p rbox.commands.member?('rye9000')   # => false
+
+# But we can add our own commands to the Rye::Cmd class. They 
+# automatically become available to all Rye::Box objects.
+module Rye::Cmd
+  def rye9000(*args)
+    run_command("ls", args)
+  end
+  def somescript(*args)
+    run_command("/path/to/my/script", args)
+  end
+end
+
+# We can now run rye9000 (with arguments)
+p rbox.rye9000('-a')                 # => [".", "..", ".bashrc", ...]
+p rbox.commands.member?('rye9000')   # => true
+
+
+puts %Q(
+# ------------------------------------------------------------------
+#   EXAMPLE 4 -- Accessing Multiple Machines
+#)
+
+rset = Rye::Set.new('default', :parallel => true)
+rbox = Rye::Box.new
+p rbox
+
+rset.add_keys('/private/key/path')     # For passwordless logins 
+rset.add_boxes(rbox, '127.0.0.1')      # Add boxes as hostnames or objects
+
+# Calling methods on Rye::Set objects is very similar to calling them on
+# Rye::Box objects. In fact, it's identical:
+p rset.uptime        # => [[14:19:02 up 32 days, 19:35 ...], [14:19:02 up 30 days, 01:35]]
+p rset['/usr'].ls    # => [['bin', 'etc', ...], ['bin', 'etc', ...]]
+
+# Like Rye::Box, the response value is a Rye::Rap object containing the
+# responses from each box. Each response is itself a Rye::Rap object.
+unames = rset.uname
+p unames                               # => [["Darwin"], ["Darwin"]]
+puts unames.class                      # => Rye::Rap
+
+# The Rye::Rap object also keeps a reference to the object that called the 
+# command. In this case, it will keep a reference to Rye::Set:
+puts unames.set.class                  # => Rye::Set
+puts unames.set == rset                # => true
+puts unames.size                       # => 2
+puts unames.first                      # => Darwin
+puts unames.first.class                # => Rye::Rap
+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.setenv(:RYE, "Forty Creek")
+p rset.env.first.select { |env| env =~ /RYE/ }  # => ["RYE=Forty Creek"]
+
+
+puts %Q(
+# ------------------------------------------------------------------
+#   EXAMPLE 5 -- ERROR HANDLING
+#)
+
+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
+# is not found by the ls command.
+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
+end
+
+# The Rye:Rap response objects also give you the STDOUT and STDERR
+# content separately. Here we redirect STDOUT to STDERR, so this
+# will return nothing:
+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 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.file_upload("#{RYE_HOME}/README.rdoc", 
+            "#{RYE_HOME}/LICENSE.txt", dir_upload)
+
+applejack = StringIO.new("Some in-memory content")
+rbox.file_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.file_download("#{dir_upload}/applejack.txt", filecontent)
+filecontent.rewind           
+p filecontent.read
+
+
+

data/lib/rye.rb

@@ -43,7 +43,7 @@ module Rye
   extend self
 
   unless defined?(SYSINFO)
-    VERSION = "0.8.0".freeze
+    VERSION = "0.8.1".freeze
     SYSINFO = SysInfo.new.freeze
   end
   

data/lib/rye/box.rb

@@ -155,28 +155,26 @@ module Rye
     #     rbox['/usr/bin'].pwd  # => /usr/bin  ($ cd /usr/bin && pwd)
     #     rbox.pwd              # => /usr/bin  ($ cd /usr/bin && pwd)
     #
-    def [](key=nil)
-      if key.nil? || key.index('/') == 0
-        @rye_current_working_directory = key
+    def [](fpath=nil)
+      if fpath.nil? || fpath.index('/') == 0
+        @rye_current_working_directory = fpath
       else
         # Append to non-absolute paths
-        newpath = File.join(@rye_current_working_directory, key)
-        @rye_current_working_directory = File.expand_path(newpath)
+        if @rye_current_working_directory
+          newpath = File.join(@rye_current_working_directory, fpath)
+          @rye_current_working_directory = newpath
+        else
+          @rye_current_working_directory = fpath
+        end
       end
+      info "CWD: #{@rye_current_working_directory}"
       self
     end
     # 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)
-      if key.nil? || key.index('/') == 0
-        @rye_current_working_directory = key
-      else
-        # Append to non-absolute paths
-        newpath = File.join(@rye_current_working_directory, key)
-        @rye_current_working_directory = File.expand_path(newpath)
-      end
-      ret = Rye::Rap.new(self)
+    def cd(fpath=nil)
+      Rye::Rap.new(self[fpath])
     end
     
     # Change the current umask (sort of -- works the same way as cd)
@@ -237,7 +235,7 @@ module Rye
     # it, execute it directly, parse the output.
     def ostype
       return @rye_ostype if @rye_ostype # simple cache
-      os = self.uname.first rescue nil
+      os = self.quietly { uname.first } rescue nil
       os ||= 'unknown'
       os &&= os.downcase
       @rye_ostype = os
@@ -256,11 +254,11 @@ module Rye
     #
     def getenv
       if @rye_getenv && @rye_getenv.empty? && self.can?(:env)
-        env = self.env rescue []
-        env.each do |nv| 
+        vars = self.quietly { env } rescue []
+        vars.each do |nvpair| 
           # 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
+          n, v = nvpair.scan(/\A([\w_-]+?)=(.+)\z/).flatten
           @rye_getenv[n] = v
         end
       end
@@ -307,6 +305,7 @@ module Rye
     # 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.
+    # Only useful before you've logged in. Otherwise check $HOME
     def guess_user_home(other_user=nil)
       this_user = other_user || opts[:user]
       @rye_guessed_homes ||= {}
@@ -321,7 +320,7 @@ module Rye
       # /etc/default/useradd, HOME=/home OR useradd -D
       # /etc/adduser.config, DHOME=/home OR ??
       user_defaults = {}
-      raw = self.useradd(:D) rescue ["HOME=/home"]
+      raw = self.quietly { useradd(:D) } rescue ["HOME=/home"]
       ostmp = self.ostype
       raw.each do |nv|
 
@@ -697,8 +696,7 @@ module Rye
       ## raise Rye::CommandNotFound unless self.can?(cmd)
       
       begin
-        info "COMMAND: #{cmd_clean}"
-        debug "Executing: #{cmd_internal}"
+        info "COMMAND: #{cmd_internal}"
 
         if !@rye_quiet && @rye_pre_command_hook.is_a?(Proc)
           @rye_pre_command_hook.call(cmd_clean, user, host, nickname) 
@@ -870,15 +868,26 @@ module Rye
 
       # 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"
+      if direction == :download 
+        if files.size == 1
+          debug "Created StringIO for download"
+          target = StringIO.new
+        else
+          target = files.pop   # The last path is the download target.
+        end
+        
+      elsif direction == :upload
+        raise "Cannot upload to a StringIO object" if target.is_a?(StringIO)
+        if files.size == 1
+          target = self.getenv['HOME'] || guess_user_home
+          debug "Assuming upload to #{target}"
+        else
+          target = files.pop
+        end
+        
+        # Expand fileglobs (e.g. path/*.rb becomes [path/1.rb, path/2.rb]).
+        # This should happen after checking files.size to determine the target
+        files = files.collect { |file| Dir.glob file }.flatten unless @rye_safe
       end
               
       # Fail early. We check whether the StringIO object is available to read
@@ -891,21 +900,21 @@ module Rye
         end
       end
       
-      debug "#{direction.to_s.upcase} TO: #{other}"
+      info "#{direction.to_s.upcase} TO: #{target}"
       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)
+      # there's more than one file because "target" could be a file name
+      if files.size > 1 && !target.is_a?(StringIO)
+        debug "CREATING TARGET DIRECTORY: #{target}"
+        self.mkdir(:p, target) unless self.file_exists?(target)
       end
       
       Net::SCP.start(@rye_host, @rye_opts[:user], @rye_opts || {}) do |scp|
         transfers = []
         files.each do |file|
           debug file.to_s
-          transfers << scp.send(direction, file, other)  do |ch, n, s, t|
+          transfers << scp.send(direction, file, target)  do |ch, n, s, t|
             pinfo "#{n}: #{s}/#{t}b\r"  # update line: "file: sent/total"
             @rye_info.flush if @rye_info        # make sure every line is printed
           end
@@ -914,7 +923,7 @@ module Rye
         info $/
       end
       
-      other.is_a?(StringIO) ? other : nil
+      target.is_a?(StringIO) ? target : nil
     end
     
 

data/lib/rye/cmd.rb

@@ -36,6 +36,7 @@ module Rye;
     def du(*args); cmd('du', args); end
     
     def env; cmd "env"; end
+    def rye(*args); cmd "rye", args; end
     def pwd(*args); cmd "pwd", args; end
     def svn(*args); cmd('svn', args); end
     def cvs(*args); cmd('cvs', args); end
@@ -50,6 +51,7 @@ module Rye;
     def grep(*args); cmd('grep', args); end
     def date(*args); cmd('date', args); end
     def ruby(*args); cmd('ruby', args); end
+    def rudy(*args); cmd('rudy', args); end
     def perl(*args); cmd('perl', args); end
     def bash(*args); cmd('bash', args); end
     def echo(*args); cmd('echo', args); end
@@ -77,8 +79,11 @@ module Rye;
     def bunzip2(*args); cmd('bunzip2', args); end
     def getconf(*args); cmd('getconf', args); end
     def history(*args); cmd('history', args); end
+    def rudy_s3(*args); cmd('rudy-s3', args); end
     def printenv(*args); cmd('printenv', args); end
     def hostname(*args); cmd('hostname', args); end
+    def rudy_ec2(*args); cmd('rudy-ec2', args); end
+    def rudy_edb(*args); cmd('rudy-sdb', args); end
     def configure(*args); cmd('./configure', args); end
     
     # Transfer files to a machine via Net::SCP. 

data/rye.gemspec

@@ -1,7 +1,7 @@
 @spec = Gem::Specification.new do |s|
   s.name = "rye"
   s.rubyforge_project = "rye"
-  s.version = "0.8.0"
+  s.version = "0.8.1"
   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"
@@ -35,7 +35,9 @@
   LICENSE.txt
   README.rdoc
   Rakefile
+  Rudyfile
   bin/rye
+  bin/try
   lib/esc.rb
   lib/rye.rb
   lib/rye/box.rb

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rye
 version: !ruby/object:Gem::Version 
-  version: 0.8.0
+  version: 0.8.1
 platform: ruby
 authors: 
 - Delano Mandelbaum
@@ -86,7 +86,9 @@ files:
 - LICENSE.txt
 - README.rdoc
 - Rakefile
+- Rudyfile
 - bin/rye
+- bin/try
 - lib/esc.rb
 - lib/rye.rb
 - lib/rye/box.rb