stella 0.6.0 → 0.7.0.002

data/lib/stella/testplan/usecase.rb

@@ -0,0 +1,67 @@
+
+
+module Stella
+class Testplan
+  
+  class Usecase
+    include Gibbler::Complex
+    attr_accessor :desc
+    attr_accessor :requests
+    attr_writer :ratio
+    attr_accessor :resources
+    attr_accessor :base_path
+    
+    def initialize(&blk)
+      @requests, @resources = [], {}
+      instance_eval &blk unless blk.nil?
+    end
+    
+    def desc(*args)
+      @desc = args.first unless args.empty?
+      @desc
+    end
+    
+    def resource(name, value=nil)
+      @resources[name] = value unless value.nil?
+      @resources[name]
+    end
+    
+    def ratio
+      r = (@ratio || 0).to_f
+      r = r/100 if r > 1 
+      r
+    end
+    
+    # Reads the contents of the file <tt>path</tt> (the current working
+    # directory is assumed to be the same directory containing the test plan).
+    def file(path)
+      path = File.join(@base_path, path) if @base_path
+      File.read(path)
+    end
+    
+    def list(path)
+      file(path).split $/
+    end
+    
+    def add_request(meth, *args, &blk)
+      req = Stella::Data::HTTP::Request.new meth.to_s.upcase, args[0], &blk
+      req.desc = args[1] if args.size > 1 # Description is optional
+      Stella.ld req
+      @requests << req
+      req
+    end
+    def get(*args, &blk);    add_request :get,    *args, &blk; end
+    def put(*args, &blk);    add_request :put,    *args, &blk; end
+    def post(*args, &blk);   add_request :post,   *args, &blk; end
+    def head(*args, &blk);   add_request :head,   *args, &blk; end
+    def delete(*args, &blk); add_request :delete, *args, &blk; end
+    
+    def xget(*args, &blk);    Stella.ld "Skipping get" end
+    def xput(*args, &blk);    Stella.ld "Skipping put" end
+    def xpost(*args, &blk);   Stella.ld "Skipping post" end
+    def xhead(*args, &blk);   Stella.ld "Skipping head" end
+    def xdelete(*args, &blk); Stella.ld "Skipping delete" end
+    
+  end
+end
+end

data/lib/stella/testplan.rb

@@ -1,237 +1,112 @@
+require 'stella/testplan/usecase'
+require 'stella/testplan/stats'
 
 module Stella
-  class TestPlan
-    class ResponseHandler
-      attr_accessor :action
-      attr_accessor :times
-      attr_accessor :wait
-      def initialize(action, times=1, wait=1)
-        @action = action
-        @times = times
-        @wait = wait
-      end
-    end
+class Testplan
+  include Gibbler::Complex
+  
+  class WackyRatio < Stella::Error
   end
-end
-
-module Stella
-
-  class TestPlan
-      # The name of the testplan. 
-    attr_accessor :name
-      # A brief description of this testplan
-    attr_accessor :description
-      # Used as the default protocol for the testplan. One of: http, https 
-    attr_accessor :protocol
-      # A Stella::TestPlan::Auth object
-    attr_accessor :auth
-      # An array of Stella::TestPlan::Request objects representing all "primary" requests
-      # for the given test plan (an html page for example). Each primary Request object can have an array of "auxilliary"
-      # requests which represent dependencies for that resource (javascript, images, callbacks, etc...).
-    attr_accessor :requests
-      
-    def initialize(name=:anonymous)
-      @name = name
-      @requests = []
-      @servers = []
-      @protocol = "http"
-    end
-    
 
-    def description
-      @description
-    end
-    def description=(val)
-      val = val.first if val.is_a? Array
-      @description = val
+  
+  attr_accessor :usecases
+  attr_accessor :base_path
+  attr_accessor :desc
+  attr_reader :stats
+  
+  def initialize
+    @desc, @usecases = "Stella's plan", []
+    @testplan_current_ratio = 0
+    @stats = Stella::Testplan::Stats.new
+  end
+  
+  def self.load_file(path)
+    conf = File.read path
+    plan = Stella::Testplan.new
+    plan.base_path = File.dirname path
+    # eval so the DSL code can be executed in this namespace.
+    plan.instance_eval conf
+    plan
+  end
+  
+  def check!
+    # Adjust ratios if necessary
+    needy = @usecases.select { |u| u.ratio == -1 }
+    needy.each do |u|
+      u.ratio = (remaining_ratio / needy.size).to_f
     end
-    
-    alias :desc  :description
-    alias :desc= :description=
-    
-    # Append a Stella::TestPlan::Request object to +requests+.
-    def add_request(req)
-      raise "That is not an instance of Stella::Data::HTTPRequest" unless req.is_a? Stella::Data::HTTPRequest
-      @requests << req
+    # Give usecases a name if necessary
+    @usecases.each_with_index { |uc,i| uc.desc ||= "Usecase ##{i+1}" }
+    if @testplan_current_ratio > 1.0 
+      msg = "Usecase ratio cannot be higher than 1.0"
+      msg << " (#{@testplan_current_ratio})"
+      raise WackyRatio, msg
     end
+  end
     
-      
-    # Creates a Stella::TestPlan::Auth object and stores it to +@auth+
-    def auth=(*args)
-      type, user, pass = args.flatten
-      @auth = Stella::Common::Auth.new(type, user, pass)
-    end
+  def usecase(*args, &blk)
+    return @usecases if args.empty?
+    ratio, name = nil,nil
+    ratio, name = args[0], args[1] if args[0].is_a?(Numeric)
+    ratio, name = args[1], args[0] if args[0].is_a?(String)
+    uc = Stella::Testplan::Usecase.new
+    uc.base_path = @base_path
+    uc.instance_eval &blk
+    uc.ratio, uc.desc = (ratio || -1).to_f, name
+    @testplan_current_ratio += uc.ratio if uc.ratio > 0
+    add_usecase uc
+  end
+  def xusecase(*args, &blk); Stella.ld "Skipping usecase"; end
+  
+  def add_usecase(uc)
+    Stella.ld "Usecase: #{uc.desc}"
+    @usecases << uc
+    uc
+  end
+  
+  def desc(*args)
+    @desc = args.first unless args.empty?
+    @desc
+  end
 
-    # A string to be parsed by URI#parsed or a URI object. The host and port are added to +@servers+ 
-    # in the form "host:port". The protocol is stored in +@protocol+. NOTE: The 
-    # protocol is used as a default for the test and if it's already set, this 
-    # method will not try to overwrite it. 
-    def base_uri=(*args)
-      uri_str = args.flatten.first
-      begin
-        uri = URI.parse uri_str
-        host_str = uri.host
-        host_str << ":#{uri.port}" if uri.port
-        @servers << host_str
-        @protocol = uri.scheme unless @protocol
-      rescue => ex
-        Stella.fatal(ex)
+  def pretty
+    str = []
+    str << " %-50s ".att(:reverse) % [@desc]
+    @usecases.each_with_index do |uc,i| 
+      description = uc.desc || "Usecase ##{i+1}"
+      str << "  %s (%s)".bright % [description, uc.ratio]
+      requests = uc.requests.each do |r| 
+        str << "    %-35s %s" % ["#{r.desc}:", r]
+        if Stella.loglev > 2
+          [:wait].each { |i| str << "      %s: %s" % [i, r.send(i)] }
+        end
       end
     end
-    
-    
+    str.join($/)
+  end
+  
+  private
+  def remaining_ratio
+    1.0 - @testplan_current_ratio
   end
-
   
 end
+end
 
-
-
-
-
-
-
-
-
-module Stella
-  module DSL
-    module TestPlan 
-      attr_accessor :current_plan
-      attr_accessor :current_request
-
-      def testplan(name, &define)
-        @plans ||= {}
-        @current_plan = @plans[name] = Stella::TestPlan.new(name)
-        define.call if define
-      end
-
-      def plans
-        @plans 
-      end
-      
-      def repeat(*args)
-        raise "Repeat format does not look like a hash" unless args.first.is_a?(Hash)
-        response_handler = Stella::TestPlan::ResponseHandler.new(:repeat)
-        [:times, :wait].each do |att|
-          response_handler.send("#{att}=", args.first[att])
-        end
-        
-        response_handler
-      end
-      
-      def body(*args)
-        
-        raise "current_plan is not a valid testplan: #{@current_plan}" unless @current_plan.is_a? Stella::TestPlan
-        
-        # NOTE: @current_request must be set in the calling namespace
-        # before this method is called. See: make_request
-        raise "current_request is not a valid request" unless @current_request.is_a? Stella::Data::HTTPRequest
-        
-        param, content_type, content = args if args.size == 3
-        param, content = args if args.size == 2
-        content = args.first if args.size == 1
-        
-        @current_request.add_body(content, param, content_type)
-      end
-      
-      def name(*args)
-        raise "current_plan is not a valid testplan: #{@current_plan}" unless @current_plan.is_a? Stella::TestPlan
-        
-        # NOTE: @current_request must be set in the calling namespace
-        # before this method is called. See: make_request
-        raise "current_request is not a valid request" unless @current_request.is_a? Stella::Data::HTTPRequest
-        @current_request.name = args.first
-      end
-      
-      
-      def response(*args, &b)
-        raise "current_plan is not a valid testplan" unless @current_plan.is_a? Stella::TestPlan
-        
-        # NOTE: @current_request must be set in the calling namespace
-        # before this method is called. See: make_request
-        raise "current_request is not a valid request" unless @current_request.is_a? Stella::Data::HTTPRequest
-        
-        @current_request.add_response_handler(*args, &b)
-      end
-      private :response
-      
-      # Stella::Data::HTTPRequest#add_ methods
-      [:header, :param].each do |method_name|
-        eval <<-RUBY, binding, '(Stella::DSL::TestPlan)', 1
-        def #{method_name}(*args, &b)
-          raise "current_plan is not a valid testplan" unless @current_plan.is_a? Stella::TestPlan
-          
-          # NOTE: @current_request must be set in the calling namespace
-          # before this method is called. See: make_request
-          raise "current_request is not a valid request" unless @current_request.is_a? Stella::Data::HTTPRequest
-          
-          @current_request.add_#{method_name}(*args, &b)
-        end
-        private :#{method_name}
-        RUBY
-      end
-      
-      # TestPlan#= methods
-      [:proxy, :auth, :base_uri, :desc, :description].each do |method_name|
-        eval <<-RUBY, binding, '(Stella::DSL::TestPlan)', 1
-        def #{method_name}(*args)
-          return unless @current_plan.is_a? Stella::TestPlan
-          @current_plan.#{method_name}=(args)
-        end
-        private :#{method_name}
-        RUBY
-      end
-      
-      # = methods 
-      [:protocol].each do |method_name|
-        eval <<-RUBY, binding, '(Stella::DSL::TestPlan)', 1
-        def #{method_name}(val)
-          return unless @current_plan.is_a? Stella::TestPlan
-          @current_plan.#{method_name}=(val.to_s)
-        end
-        private :#{method_name}
-        RUBY
-      end
-      
-      def post(uri, &define)
-        make_request(:POST, uri, &define)
-      end
-        def xpost(*args); end;
-        def xget(*args); end;
-      
-      def get(uri, &define)
-        make_request(:GET, uri, &define)
-      end
-      
-    private
-      
-      def make_request(method, uri, &define)
-        return unless @current_plan.is_a? Stella::TestPlan
-        req = Stella::Data::HTTPRequest.new(uri, method.to_s.upcase)
-        @current_plan.add_request req
-        index = @current_plan.requests.size
-        method_name = :"#{index} #{req.http_method} #{req.uri}"
-        
-        req_method = Proc.new {
-          # These instance variables are very important. The bring in the context
-          # when the request method is called in the testrunner class. We know what 
-          # the current plan is while we're executing the DSL blocks to define the 
-          # request. The response block however, is called only after a require request
-          # is made. We set these instance variables so that the response block will
-          # know what request it's associated too.  
-          instance_variable_set('@current_plan', @current_plan)
-          instance_variable_set('@current_request', req)
-          define.call if define
-          req
-        }
-        metaclass.instance_eval do
-          define_method(method_name, &req_method) 
-        end
-
-      end
-      
+__END__
+# instance_exec for Ruby 1.8 written by Mauricio Fernandez
+# http://eigenclass.org/hiki/instance_exec
+if RUBY_VERSION =~ /1.8/
+  module InstanceExecHelper; end
+  include InstanceExecHelper
+  def instance_exec(*args, &block) # !> method redefined; discarding old instance_exec
+    mname = "__instance_exec_#{Thread.current.object_id.abs}_#{object_id.abs}"
+    InstanceExecHelper.module_eval{ define_method(mname, &block) }
+    begin
+      ret = send(mname, *args)
+    ensure
+      InstanceExecHelper.module_eval{ undef_method(mname) } rescue nil
     end
+    ret
   end
 end
-
-

data/lib/stella/utils.rb

@@ -0,0 +1,126 @@
+
+require 'socket'
+require 'open-uri'
+require 'date'
+
+require 'timeout'
+
+module Stella
+  
+  # A motley collection of methods that Stella loves to call!
+  module Utils
+    extend self
+    include Socket::Constants
+    
+    # Return the external IP address (the one seen by the internet)
+    def external_ip_address
+      ip = nil
+      begin
+        %w{solutious.heroku.com/ip}.each do |sponge|
+          ipstr = Net::HTTP.get(URI.parse("http://#{sponge}")) || ''
+          ip = /([0-9]{1,3}\.){3}[0-9]{1,3}/.match(ipstr).to_s
+          break if ip && !ip.empty?
+        end
+      rescue SocketError, Errno::ETIMEDOUT => ex
+        Stella.le "Connection Error. Check your internets!"
+      end
+      ip
+    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 internal_ip_address
+      # turn off reverse DNS resolution temporarily 
+      orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true   
+      ip = UDPSocket.open {|s| s.connect('75.101.137.7', 1); s.addr.last } # Solutious IP
+      ip
+    ensure  
+      Socket.do_not_reverse_lookup = orig
+    end
+    
+    
+    # <tt>require</tt> a glob of files. 
+    # * +path+ is a list of path elements which is sent to File.join 
+    # and then to Dir.glob. The list of files found are sent to require. 
+    # Nothing is returned but LoadError exceptions are caught. The message
+    # is printed to STDERR and the program exits with 7. 
+    def require_glob(*path)
+      begin
+        Dir.glob(File.join(*path.flatten)).each do |path|
+          require path
+        end
+      rescue LoadError => ex
+        puts "Error: #{ex.message}"
+        exit 7
+      end
+    end
+    
+    # Checks whether something is listening to a socket. 
+    # * +host+ A hostname
+    # * +port+ The port to check
+    # * +wait+ The number of seconds to wait for before timing out. 
+    #
+    # Returns true if +host+ allows a socket connection on +port+. 
+    # Returns false if one of the following exceptions is raised:
+    # Errno::EAFNOSUPPORT, Errno::ECONNREFUSED, SocketError, Timeout::Error
+    #
+    def service_available?(host, port, wait=3)
+      if Stella.sysinfo.vm == :java
+        begin
+          iadd = Java::InetSocketAddress.new host, port      
+          socket = Java::Socket.new
+          socket.connect iadd, wait * 1000  # milliseconds
+          success = !socket.isClosed && socket.isConnected
+        rescue NativeException => ex
+          puts ex.message, ex.backtrace if Stella.debug?
+          false
+        end
+      else 
+        begin
+          status = Timeout::timeout(wait) do
+            socket = Socket.new( AF_INET, SOCK_STREAM, 0 )
+            sockaddr = Socket.pack_sockaddr_in( port, host )
+            socket.connect( sockaddr )
+          end
+          true
+        rescue Errno::EAFNOSUPPORT, Errno::ECONNREFUSED, SocketError, Timeout::Error => ex
+          puts ex.class, ex.message, ex.backtrace if Stella.debug?
+          false
+        end
+      end
+    end
+    
+    # A basic file writer
+    def write_to_file(filename, content, mode, chmod=600)
+      mode = (mode == :append) ? 'a' : 'w'
+      f = File.open(filename,mode)
+      f.puts content
+      f.close
+      return unless Stella.sysinfo.os == :unix
+      raise "Provided chmod is not a Fixnum (#{chmod})" unless chmod.is_a?(Fixnum)
+      File.chmod(chmod, filename)
+    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
+    
+    # Returns +str+ with the leading indentation removed. 
+    # Stolen from http://github.com/mynyml/unindent/ because it was better.
+    def noindent(str)
+      indent = str.split($/).each {|line| !line.strip.empty? }.map {|line| line.index(/[^\s]/) }.compact.min
+      str.gsub(/^[[:blank:]]{#{indent}}/, '')
+    end
+    
+  end
+end

data/lib/stella/version.rb

@@ -0,0 +1,15 @@
+
+
+module Stella
+  module Version
+    unless defined?(MAJOR)
+      MAJOR = 0.freeze
+      MINOR = 7.freeze
+      TINY  = 0.freeze
+      PATCH = '001'.freeze
+    end
+    def self.to_s; [MAJOR, MINOR, TINY].join('.'); end
+    def self.to_f; self.to_s.to_f; end
+    def self.patch; PATCH; end
+  end
+end