rye 0.3

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"
+  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[try]
+  
+  
+  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

data/test/10_rye_test.rb

@@ -0,0 +1,63 @@
+#!/usr/bin/ruby
+
+# 
+# Usage: test/10_rye_test.rb
+#
+
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'benchmark'
+require 'rubygems'
+require 'stringio'
+require 'yaml'
+require 'rye'
+
+
+machine_key = {
+  :host => 'ryehost',
+  :user => "root",
+  :key => '/proj/git/rudy/.rudy/key-test-app.private'
+}
+
+machine_pass = {
+  :host => 'ryehost',
+  :user => 'pablo',
+  :pass => 'pablo9001'
+}
+
+machine_local = {
+  :host => "localhost"
+}
+
+rbox_key = Rye::Box.new(machine_key[:host], :user => machine_key[:user], :keys => machine_key[:key])
+rbox_pass = Rye::Box.new(machine_pass[:host], :user => machine_pass[:user], :password=> machine_pass[:pass])
+rbox_local = Rye::Box.new(machine_local[:host], :safe => false)
+
+
+rset_serial = Rye::Set.new("example", :parallel => false) #, :debug => STDOUT
+rset_parallel = Rye::Set.new("example", :parallel => true)
+rset_serial.add_boxes(rbox_key, rbox_local, rbox_pass)
+rset_parallel.add_boxes(rbox_key, rbox_local, rbox_pass)
+
+# The Rehersal will be slower because they'll include the connection time
+Benchmark.bmbm do |x|
+  x.report('rbox:       ') { puts "%10s:%s:%s" % [rbox_key.uname, rbox_local.uname, rbox_pass.uname] }
+  x.report('rset-S:') { puts "%10s:%s:%s" % rset_serial.uname }
+  x.report('rset-P:') { puts "%10s:%s:%s" % rset_parallel.uname }
+end
+
+__END__
+
+#p rset.sleep(1)
+
+p rbox_remote.echo('$HOME')
+
+local_files = rbox_local['/tmp/ssh-test'].ls
+remote_files = rbox_remote['/etc/ssh'].ls
+diff = remote_files - local_files
+
+puts "ETC DIFF:"
+puts diff
+
+rbox_remote = Rye::Box.new('ec2-75-101-255-188.compute-1.amazonaws.com', :user => 'root', :debug => STDOUT, :safe => false, :keys => '/proj/git/rudy/.rudy/key-test-app.private')
+

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: rye
+version: !ruby/object:Gem::Version 
+  version: "0.3"
+platform: ruby
+authors: 
+- Delano Mandelbaum
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-04-04 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: net-ssh
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: highline
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: "Rye: Run system commands via SSH locally and remotely in a Ruby way."
+email: delano@solutious.com
+executables: 
+- try
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE.txt
+files: 
+- 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
+has_rdoc: true
+homepage: http://solutious.com/
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --title
+- "Rye: Run system commands via SSH locally and remotely in a Ruby way."
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: rye
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: "Rye: Run system commands via SSH locally and remotely in a Ruby way."
+test_files: []
+