delano-rye 0.3.2

data/lib/rye/set.rb

@@ -0,0 +1,147 @@
+module Rye
+  
+  # = Rye::Set
+  #
+  #
+  class Set
+    attr_reader :name
+    attr_reader :boxes
+    
+    # * +name+ The name of the set of machines
+    # * +opts+ a hash of optional arguments 
+    #
+    # The +opts+ hash is used as defaults for all for all Rye::Box objects. 
+    # All args supported by Rye::Box are available here with the addition of:
+    #
+    # * :parallel => run the commands in parallel? true or false (default).
+    #
+    def initialize(name='default', opts={})
+      @name = name
+      @boxes = []
+      
+      # These opts are use by Rye::Box and also passed to Net::SSH
+      @opts = {
+        :parallel => false,
+        :user => Rye.sysinfo.user, 
+        :safe => true,
+        :port => 22,
+        :keys => [],
+        :password => nil,
+        :proxy => nil,
+        :debug => nil,
+        :error => STDERR,
+      }.merge(opts)
+      
+      @parallel = @opts.delete(:parallel) # Rye::Box doesn't have :parallel
+      
+      @safe = @opts.delete(:safe)
+      @debug = @opts.delete(:debug)
+      @error = @opts.delete(:error)
+
+      add_keys(@opts[:keys])
+    end
+    
+    # * +boxes+ one or more boxes. Rye::Box objects will be added directly 
+    # to the set. Hostnames will be used to create new instances of Rye::Box 
+    # and those will be added to the list. 
+    def add_box(*boxes)
+      boxes = boxes.flatten.compact 
+      @boxes += boxes.collect do |box|
+        box.is_a?(Rye::Box) ? box.add_keys(@keys) : Rye::Box.new(box, @opts)
+      end
+      self
+    end
+    alias :add_boxes :add_box
+    
+    # Add one or more private keys to the SSH Agent. 
+    # * +additional_keys+ is a list of file paths to private keys
+    # Returns the instance of Rye::Set
+    def add_key(*additional_keys)
+      additional_keys = [additional_keys].flatten.compact || []
+      Rye.add_keys(additional_keys)
+      self
+    end
+    alias :add_keys :add_key
+    
+    # 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)
+      self
+    end
+    alias :add_environment_variable :add_env
+    
+    # See Rye.keys
+    def keys
+      Rye.keys
+    end
+    
+    # See Rye::Box.[]
+    def [](key=nil)
+      run_command(:cd, key)
+      self
+    end
+    alias :cd :'[]'
+    
+    # Catches calls to Rye::Box commands. If +meth+ is the name of an 
+    # instance method defined in Rye::Cmd then we call it against all 
+    # the boxes in +@boxes+. Otherwise this method raises a
+    # Rye::CommandNotFound exception. It will also raise a Rye::NoBoxes
+    # exception if this set has no boxes defined. 
+    #
+    # Returns a Rye::Rap object containing the responses from each Rye::Box. 
+    def method_missing(meth, *args)
+      # Ruby 1.8 populates Module.instance_methods with Strings. 1.9 uses Symbols.
+      meth = (Rye.sysinfo.ruby[1] == 8) ? meth.to_s : meth.to_sym
+      raise Rye::NoBoxes if @boxes.empty?
+      raise Rye::CommandNotFound, meth.to_s unless Rye::Cmd.instance_methods.member?(meth)
+      run_command(meth, *args)
+    end
+    
+  private
+    
+    # Determines whether to call the serial or parallel method, then calls it. 
+    def run_command(meth, *args)
+      runner = @parallel ? :run_command_parallel : :run_command_serial
+      self.send(runner, meth, *args)
+    end
+    
+    
+    # Run the command on all boxes in parallel
+    def run_command_parallel(meth, *args)
+      debug "P: #{meth} on #{@boxes.size} boxes (#{@boxes.collect {|b| b.host }.join(', ')})"
+      threads = []
+      
+      raps = Rye::Rap.new(self)
+      (@boxes || []).each do |box|
+        threads << Thread.new do
+          Thread.current[:rap] = box.send(meth, *args) # Store the result in the thread
+        end
+      end
+      
+      threads.each do |t| 
+        sleep 0.01        # Give the thread some breathing room
+        t.join            # Wait for the thread to finish
+        raps << t[:rap]   # Grab the result
+      end
+      
+      raps
+    end
+    
+    
+    # Run the command on all boxes in serial
+    def run_command_serial(meth, *args)
+      debug "S: #{meth} on #{@boxes.size} boxes (#{@boxes.collect {|b| b.host }.join(', ')})"
+      raps = Rye::Rap.new(self)
+      (@boxes || []).each do |box|
+        raps << box.send(meth, *args)
+      end
+      raps
+    end
+    
+    def debug(msg); @debug.puts msg if @debug; end
+    def error(msg); @error.puts msg if @error; end
+  
+  end
+  
+end

data/lib/sys.rb

@@ -0,0 +1,274 @@
+require 'socket'
+
+# SystemInfo
+# 
+# A container for the platform specific system information. 
+# Portions of this code were originally from Amazon's EC2 AMI tools, 
+# specifically lib/platform.rb. 
+class SystemInfo #:nodoc:all
+  VERSION = 2
+  IMPLEMENTATIONS = [
+    
+    # These are for JRuby, System.getproperty('os.name'). 
+    # For a list of all values, see: http://lopica.sourceforge.net/os.html
+    [/mac\s*os\s*x/i,     :unix,    :osx     ],  
+    [/sunos/i,            :unix,    :solaris ], 
+    [/windows\s*ce/i,     :win32,   :windows ],
+    [/windows/i,          :win32,   :windows ],  
+    [/osx/i,              :unix,    :osx     ],
+    
+    # TODO: implement other windows matches: # /djgpp|(cyg|ms|bcc)win|mingw/ (from mongrel)
+    
+    # These are for RUBY_PLATFORM and JRuby
+    [/java/i,    :java,    :java             ],
+    [/darwin/i,  :unix,    :osx              ],
+    [/linux/i,   :unix,    :linux            ],
+    [/freebsd/i, :unix,    :freebsd          ],
+    [/netbsd/i,  :unix,    :netbsd           ],
+    [/solaris/i, :unix,    :solaris          ],
+    [/irix/i,    :unix,    :irix             ],
+    [/cygwin/i,  :unix,    :cygwin           ],
+    [/mswin/i,   :win32,   :windows          ],
+    [/mingw/i,   :win32,   :mingw            ],
+    [/bccwin/i,  :win32,   :bccwin           ],
+    [/wince/i,   :win32,   :wince            ],
+    [/vms/i,     :vms,     :vms              ],
+    [/os2/i,     :os2,     :os2              ],
+    [nil,        :unknown, :unknown          ],
+    
+  ]
+
+  ARCHITECTURES = [
+    [/(i\d86)/i,  :i386             ],
+    [/x86_64/i,   :x86_64           ],
+    [/x86/i,      :i386             ],  # JRuby
+    [/ia64/i,     :ia64             ],
+    [/alpha/i,    :alpha            ],
+    [/sparc/i,    :sparc            ],
+    [/mips/i,     :mips             ],
+    [/powerpc/i,  :powerpc          ],
+    [/universal/i,:universal        ],
+    [nil,         :unknown          ],
+  ]
+  
+
+
+  attr_reader :os 
+  attr_reader :implementation
+  attr_reader :architecture 
+  attr_reader :hostname 
+  attr_reader :ipaddress 
+  attr_reader :uptime 
+  
+  
+  alias :impl :implementation
+  alias :arch :architecture
+
+  
+  def initialize
+    @os, @implementation, @architecture = guess
+    @hostname, @ipaddress, @uptime = get_info
+  end
+  
+  # guess
+  #
+  # This is called at require-time in stella.rb. It guesses
+  # the current operating system, implementation, architecture. 
+  # Returns [os, impl, arch]
+  def guess
+    os = :unknown
+    impl = :unknown
+    arch = :unknown
+    IMPLEMENTATIONS.each do |r, o, i|
+      if r and RUBY_PLATFORM =~ r
+        os, impl = [o, i]
+        break
+      end
+    end
+    ARCHITECTURES.each do |r, a|
+      if r and RUBY_PLATFORM =~ r
+        arch = a
+        break
+      end
+    end
+    
+    #
+    if os == :win32
+      #require 'Win32API'
+
+    # If we're running in java, we'll need to look elsewhere
+    # for the implementation and architecture. 
+    # We'll replace IMPL and ARCH with what we find. 
+    elsif os == :java
+      require 'java'
+      include_class java.lang.System
+      
+      osname = System.getProperty("os.name")
+      IMPLEMENTATIONS.each do |r, o, i|
+        if r and osname =~ r
+          impl = i
+          break
+        end
+      end
+      
+      osarch = System.getProperty("os.arch")
+      ARCHITECTURES.each do |r, a|
+        if r and osarch =~ r
+          arch = a
+          break
+        end
+      end
+      
+    end
+
+    [os, impl, arch]
+  end
+
+  # get_info
+  #
+  # Returns [hostname, ipaddr, uptime] for the local machine
+  def get_info
+    hostname = :unknown
+    ipaddr = :unknown
+    uptime = :unknown
+
+    begin
+      hostname = local_hostname
+      ipaddr = local_ip_address
+      uptime = local_uptime       
+    rescue => ex
+      # Be silent!
+    end
+
+    [hostname, ipaddr, uptime]
+  end
+
+  # local_hostname
+  #
+  # Return the hostname for the local machine
+  def local_hostname
+    Socket.gethostname
+  end
+  
+  # local_uptime
+  #
+  # Returns the local uptime in hours. Use Win32API in Windows, 
+  # 'sysctl -b kern.boottime' os osx, and 'who -b' on unix.
+  # Based on Ruby Quiz solutions by: Matthias Reitinger 
+  # On Windows, see also: net statistics server
+  def local_uptime
+
+    # Each method must return uptime in seconds
+    methods = {
+
+      :win32_windows => lambda {
+        # Win32API is required in self.guess
+        getTickCount = Win32API.new("kernel32", "GetTickCount", nil, 'L')
+        ((getTickCount.call()).to_f / 1000).to_f
+      },
+
+      # Ya, this is kinda wack. Ruby -> Java -> Kernel32. See:
+      # http://www.oreillynet.com/ruby/blog/2008/01/jruby_meets_the_windows_api_1.html
+      # http://msdn.microsoft.com/en-us/library/ms724408(VS.85).aspx
+      # Ruby 1.9.1: Win32API is now deprecated in favor of using the DL library.
+      :java_windows => lambda {
+        kernel32 = com.sun.jna.NativeLibrary.getInstance('kernel32')
+        buf = java.nio.ByteBuffer.allocate(256)
+        (kernel32.getFunction('GetTickCount').invokeInt([256, buf].to_java).to_f / 1000).to_f 
+      },
+      
+      :unix_osx => lambda {
+        # This is faster than who and could work on BSD also. 
+        (Time.now.to_f - Time.at(`sysctl -b kern.boottime 2>/dev/null`.unpack('L').first).to_f).to_f
+      },
+      # This should work for most unix flavours. 
+      :unix => lambda {
+        # who is sloooooow. Use File.read('/proc/uptime')
+        (Time.now.to_f - Time.parse(`who -b 2>/dev/null`).to_f)
+      }
+    }
+
+    hours = 0
+    
+    begin
+      key = platform
+      method = (methods.has_key? key) ? methods[key] : methods[:unix]
+      hours = (method.call) / 3600 # seconds to hours
+    rescue => ex
+    end
+    hours
+  end
+
+
+  #
+  # Return the local IP address which receives external traffic
+  # from: http://coderrr.wordpress.com/2008/05/28/get-your-local-ip-address/
+  # NOTE: This <em>does not</em> open a connection to the IP address. 
+  def local_ip_address
+    # turn off reverse DNS resolution temporarily 
+    orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true   
+    UDPSocket.open {|s| s.connect('75.101.137.7', 1); s.addr.last } # Solutious IP
+  ensure  
+    Socket.do_not_reverse_lookup = orig
+  end
+
+  #
+  # Returns the local IP address based on the hostname. 
+  # According to coderrr (see comments on blog link above), this implementation
+  # doesn't guarantee that it will return the address for the interface external
+  # traffic goes through. It's also possible the hostname isn't resolvable to the
+  # local IP.  
+  def local_ip_address_alt
+    ipaddr = :unknown
+    begin
+      saddr = Socket.getaddrinfo(  Socket.gethostname, nil, Socket::AF_UNSPEC, Socket::SOCK_STREAM, nil, Socket::AI_CANONNAME)
+      ipaddr = saddr.select{|type| type[0] == 'AF_INET' }[0][3]
+    rescue => ex
+    end
+    ipaddr
+  end
+
+  # returns a symbol in the form: os_implementation. This is used throughout Stella
+  # for platform specific support. 
+  def platform
+    "#{@os}_#{@implementation}".to_sym
+  end
+  
+  # Returns Ruby version as an array
+  def ruby
+    RUBY_VERSION.split('.').map { |v| v.to_i }
+  end
+  
+  # Returns the environment PATH as an Array
+  def paths
+    if @os == :unix
+      (ENV['PATH'] || '').split(':')
+    elsif
+      (ENV['PATH'] || '').split(';') # Note tested!
+    else
+      raise "paths not implemented for: #{@os}"
+    end
+  end
+  
+  def user
+    ENV['USER']
+  end
+  
+  def home
+    if @os == :unix
+      File.expand_path(ENV['HOME'])
+    elsif @os == :win32
+      File.expand_path(ENV['USERPROFILE'])
+    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('.')}", 
+      @hostname, @ipaddress, "#{@os}-#{@implementation}-#{@architecture}", @uptime)
+  end
+  
+  
+end

data/rye.gemspec

@@ -0,0 +1,56 @@
+@spec = Gem::Specification.new do |s|
+  s.name = "rye"
+  s.rubyforge_project = "rye"
+  s.version = "0.3.2"
+  s.summary = "Rye: Run system commands via SSH locally and remotely in a Ruby way."
+  s.description = s.summary
+  s.author = "Delano Mandelbaum"
+  s.email = "delano@solutious.com"
+  s.homepage = "http://solutious.com/"
+  
+  # = DEPENDENCIES =
+  # Add all gem dependencies
+  s.add_dependency 'net-ssh'
+  s.add_dependency 'highline'
+  
+  # = 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
+  # error. You can ask your VCS for the list of versioned files:
+  # git ls-files
+  # svn list -R
+  s.files = %w(
+  CHANGES.txt
+  LICENSE.txt
+  README.rdoc
+  Rakefile
+  bin/try
+  lib/esc.rb
+  lib/rye.rb
+  lib/rye/box.rb
+  lib/rye/cmd.rb
+  lib/rye/rap.rb
+  lib/rye/set.rb
+  lib/sys.rb
+  rye.gemspec
+  test/10_rye_test.rb
+  )
+  
+  # = EXECUTABLES =
+  # The list of executables in your project (if any). Don't include the path, 
+  # just the base filename.
+  #s.executables = %w[]
+  
+  
+  s.extra_rdoc_files = %w[README.rdoc LICENSE.txt]
+  s.has_rdoc = true
+  s.rdoc_options = ["--line-numbers", "--title", s.summary, "--main", "README.rdoc"]
+  s.require_paths = %w[lib]
+  s.rubygems_version = '1.3.0'
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+  end
+  
+end