stella 0.5.5 → 0.6.0

data/lib/stella/support.rb

@@ -1,276 +0,0 @@
-
-
-
-module Stella
-  
-  class InvalidArgument < RuntimeError
-    attr_accessor :name
-    def initialize(name)
-      @name = name
-    end
-    def message
-      Stella::TEXT.err(:error_invalid_argument, @name)
-    end
-    
-  end
-  
-  class UnavailableAdapter < RuntimeError
-    attr_accessor :name
-    def initialize(name)
-      @name = name
-    end
-    def message
-      Stella::TEXT.err(:error_unavailable_adapter, @name)
-    end
-  end
-  
-  class UnknownValue < RuntimeError
-    attr_accessor :value
-    def initialize(value)
-      @value = value.to_s
-    end
-    def message
-      Stella::TEXT.err(:error_unknown_value, @value)
-    end
-  end
-  
-  class UnsupportedLanguage < RuntimeError
-  end
-  
-  class MissingDependency < RuntimeError
-    attr_accessor :dependency, :reason
-    def initialize(dependency, reason=:error_generic)
-      @dependency = dependency
-      @reason = (reason.kind_of? Symbol) ? Stella::TEXT.err(reason) : reason
-    end
-    def message
-      Stella::TEXT.err(:error_missing_dependency, @dependency, @reason)
-    end
-  end
-  
-  class AdapterError < MissingDependency
-    def initialize(adapter, reason=:error_generic)
-      @adapter = adapter
-      @reason = (reason.kind_of? Symbol) ? Stella::TEXT.err(reason) : reason
-    end
-    def message
-      Stella::TEXT.err(:error_adapter_runtime, @adapter, @reason)
-    end
-  end
-  
-  class Util
-    
-    BrowserNicks = {
-      :ff => 'firefox',
-      :ie => 'internetexplorer'
-    }.freeze unless defined? BrowserNicks
-
-    OperatingSystemNicks = {
-      :win => 'windows',
-      :lin => 'linux',
-      :osx => 'osx',
-      :freebsd => 'bsd',
-      :netbsd => 'bsd',
-      :openbsd => 'bsd'
-    }.freeze unless defined? OperatingSystemNicks
-    
-    # process_useragents
-    #
-    # We read the useragents.txt file into a hash index which 
-    # useful for refering to specific useragents on the command-line
-    # and other places. 
-    # 
-    # Examples:
-    #      --agent=ie-5
-    #      --agent=ff-2.0.0.2-linux
-    #      --agent=chrome-windows
-    #      --agent=safari-3.0-osx
-    # 
-    def self.process_useragents(path=nil)
-      raise "Cannot find #{path}" unless File.exists? path
-      ua_strs = FileUtil.read_file_to_array(path)
-      return {} if ua_strs.empty?
-      
-      agents_index = {}
-      ua_strs.each do |ua_str|
-        ua_str.chomp!   # remove trailing line separator
-
-        ua = UserAgent.parse(ua_str)
-        
-        # Standardize the index values
-        # i.e. firefox-3-windows
-        name = ua.browser.downcase.tr(' ', '')
-        version = ua.version.to_i
-        os = ua.platform.downcase.tr(' ', '')
-
-        # Non-windows operating systems have the OS string inside of "os"
-        # rather than "platform". We look there for the value and then
-        # standardize the values. 
-        # i.e. firefox-3-osx
-        if os != 'windows'
-          os = ua.os.downcase
-          os = 'linux' if os.match(/^linux/)
-          os = 'osx' if os.match(/mac os x/)
-          os = 'bsd' if os.match(/bsd/)
-        end
-
-        # Make sure all arrays exist before we populate them
-        agents_index[name] ||= []
-        agents_index["#{name}-#{version}"] ||= []
-        agents_index["#{name}-#{version}-#{os}"] ||= []
-        agents_index["#{name}-#{os}"] ||= [] # We use this one for failover
-
-        # Populate each list. 
-        agents_index[name] << ua
-        agents_index["#{name}-#{version}"] << ua
-        agents_index["#{name}-#{version}-#{os}"] << ua
-        agents_index["#{name}-#{os}"] << ua
-
-      end
-
-      agents_index
-    end
-    
-    def self.find_agents(agent_list, possible_agents=[])
-      return [] if agent_list.nil? || agent_list.empty?
-      return [] if possible_agents.nil? || possible_agents.empty?
-      
-      agents = []
-      possible_agents.each do |a|
-        agents << Stella::Util.find_agent(agent_list, *a)
-      end
-      
-      agents
-    end
-    
-    # find_agent
-    #
-    # Takes an input string which can be either a shortname or a complete
-    # user agent string. If the string matches the shortname format, it
-    # will select an agent string from useragents.txt based on the shortname.
-    # Shortname takes the following format: browser-version-os. 
-    # Examples: ff-3-linux, ie-5, opera-10-win, chrome-0.2-osx, random
-    # If os doesn't match, it will look for the browser and version. If it can't
-    # find the version it will look for the browser and apply the version given. 
-    # If browser doesn't match a known browser, it assumes the string is a 
-    # complete user agent and simply returns that value. 
-    def self.find_agent(agent_list, name,second=nil,third=nil)
-      return '' if agent_list.nil? || agent_list.empty?
-      name = (BrowserNicks.has_key?(name.to_s.to_sym)) ? BrowserNicks[name.to_s.to_sym] : name
-      return name unless agent_list.has_key?(name) || name == "random"
-
-      index = name
-      if (second && third)                # i.e. opera-9-osx
-        os = (OperatingSystemNicks.has_key?(third)) ? OperatingSystemNicks[third] : third
-        index = "#{name}-#{second}-#{os}"
-      elsif(second && second.to_i > 0)    # i.e. opera-9
-        index = "#{name}-#{second}"
-      elsif(second)                       # i.e. opera-osx
-        os = (OperatingSystemNicks.has_key?(second)) ? OperatingSystemNicks[second] : second
-        index = "#{name}-#{os}"
-      elsif(name == "random")
-        index = agent_list.keys[ rand(agent_list.keys.size) ]
-      end
-
-      # Attempt to find a pool of user agents that match the supplied index
-      ua_pool = agent_list[index]
-
-      # In the event we don't find an agent above (which will only happen
-      # when the user provided a version), we'll take a random agent for 
-      # the same browser and apply the version supplied by the user. We 
-      # create the index using just the major version number so if the user
-      # supplies a specific verswion number, they will always end up here.
-      unless ua_pool
-        os = (OperatingSystemNicks.has_key?(third)) ? OperatingSystemNicks[third] : third
-        index = (os) ? "#{name}-#{os}" : name
-        ua_tmp = agent_list[index][ rand(agent_list[index].size) ]
-        ua_tmp.version = second if second.to_i > 0
-        ua_pool = [ua_tmp]
-      end
-      
-      ua = ua_pool[ rand(ua_pool.size) ]
-      
-      ua.to_s
-
-    end
-    
-    # expand_str
-    # 
-    # Turns a string like ff-4-freebsd into ["ff","4","freebsd"]
-    # We use this for command-line values liek agent and rampup.
-    # +str+ is a comma or dash separated string.
-    # +type+ is a class type to cast to (optional, default: String)
-    def self.expand_str(str, type=String)
-      # this removes extra spaces along with the comma
-      str.split(/\s*[,\-]\s*/).inject([]) do |list,value| list << eval("#{type}('#{value}')") end
-    end
-    
-    
-    # capture_output
-    #
-    # +cmd+ is a shell command to run with Kernel.` It will be appended with 
-    # redirects to send STDOUT and STDERR to temp files. If the command already
-    # contains redirects they will be removed and replaced. 
-    # The tempfiles are sent to yield as arrays of lines (using file_sout.readlines)
-    # and deleted before returning. 
-    #
-    # We use files because popen and open3 are not implemented on Windows. 
-    def self.capture_output(cmd)
-      return unless cmd
-      file_sout = Tempfile.new("stdout" << strand(6)) # We add a strand to be super sure it doesn't exist
-      file_serr = Tempfile.new("stderr" << strand(6))
-      cmd.gsub!(/1>.+/, '')
-      cmd.gsub!(/2>.+/, '')
-      cmd = "#{cmd} 1> \"#{file_sout.path}\" 2> \"#{file_serr.path}\""
-      begin
-        # Windows will have a conniption because the tempfiles are already open.
-        # We close them here and then open them to read them. 
-        file_sout.close
-        file_serr.close
-        
-        system(cmd)
-        
-        file_sout.open
-        file_serr.open
-        sout, serr = file_sout.readlines, file_serr.readlines
-        file_sout.close
-        file_serr.close
-        
-        yield(sout, serr)
-        
-      ensure
-        file_sout.delete
-        file_serr.delete
-      end
-    end
-    
-    # NOTE: Not used yet
-    # TODO: Use capture instead of capture_output
-    # Stolen from http://github.com/wycats/thor
-    def capture(stream)
-      begin
-        stream = stream.to_s
-        eval "$#{stream} = StringIO.new"
-        yield
-        result = eval("$#{stream}").string
-      ensure
-        eval("$#{stream} = #{stream.upcase}")
-      end
-
-      result
-    end
-    
-    
-    # 
-    # Generates a string of random alphanumeric characters
-    # These are used as IDs throughout the system
-    def self.strand( len )
-       chars = ("a".."z").to_a + ("0".."9").to_a
-       newpass = ""
-       1.upto(len) { |i| newpass << chars[rand(chars.size-1)] }
-       return newpass
-    end
-    
-  end
-  
-end

data/lib/stella/sysinfo.rb

@@ -1,257 +0,0 @@
-
-
-module Stella
-  # Stella::SystemInfo
-  # 
-  # A container for the system platform information. 
-  # Portions of this code is from Amazon's EC2 AMI tools, lib/platform.rb. 
-  class SystemInfo < Stella::Storable
-    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          ],
-    ]
-    
-
-  
-    field :os => String
-    field :implementation => String
-    field :architecture => String
-    field :hostname => String
-    field :ipaddress => String
-    field :uptime => Float
-    
-    
-    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
-      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
-
-
-    # local_ip_address
-    #
-    # 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
-
-    # local_ip_address_alt
-    #
-    # 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
-
-    # platform
-    #
-    # returns a symbol in the form: os_implementation. This is used throughout Stella
-    # for platform specific support. 
-    def platform
-      "#{@os}_#{@implementation}".to_sym
-    end
-    
-    # ruby
-    #
-    # Returns Ruby version as an array
-    def ruby
-      RUBY_VERSION.split('.').map { |v| v.to_i }
-    end
-    
-    # to_s
-    # 
-    # 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
-end