stella 0.6.0 → 0.7.0.002

data/lib/stella/client.rb

@@ -0,0 +1,199 @@
+require "observer"
+require "tempfile"
+require 'httpclient'
+require 'nokogiri'
+
+module Stella
+  class Client
+    include Observable
+    attr_reader :client_id
+    attr_accessor :base_uri
+    attr_accessor :proxy
+    attr_reader :stats
+    def initialize(base_uri=nil, client_id=1)
+      @base_uri, @client_id = base_uri, client_id
+      @cookie_file = Tempfile.new('stella-cookie')
+      @stats = Stella::Stats.new("Client #{@client_id}")
+    end
+    
+    def execute(usecase)
+      http_client = generate_http_client
+      container = Container.new(usecase)
+      counter = 0
+      usecase.requests.each do |req|
+        counter += 1
+        uri_obj = URI.parse(req.uri)
+        params = prepare_params(usecase, req.params)
+        uri = build_request_uri uri_obj, params, container
+        raise NoHostDefined, uri_obj if uri.host.nil? || uri.host.empty?
+        
+        meth = req.http_method.to_s.downcase
+        Stella.ld "#{meth}: " << "#{uri_obj.to_s} " << req.params.inspect
+        
+        changed and notify_observers(:send_request, @client_id, usecase, meth, uri, req, params, counter)
+        begin
+          container.response = http_client.send(meth, uri, params) # booya!
+          changed and notify_observers(:receive_response, @client_id, usecase, meth, uri, req, params, container)
+        rescue => ex
+          changed and notify_observers(:request_error, @client_id, usecase, meth, uri, req, params, ex)
+          next
+        end
+        
+        
+        ret = execute_response_handler container, req
+        
+        Drydock::Screen.flush
+        
+        if ret.kind_of?(ResponseModifier)
+          case ret.class.to_s
+          when "Stella::Client::Repeat"
+            Stella.ld "REPETITION: #{counter} of #{ret.times+1}"
+            redo if counter <= ret.times
+          end
+        end
+        
+        counter = 0 # reset
+        run_sleeper(req.wait) if req.wait && !benchmark?
+      end
+    end
+    
+    def enable_benchmark_mode; @bm = true; end
+    def disable_benchmark_mode; @bm = false; end
+    def benchmark?; @bm == true; end
+      
+  private
+    def run_sleeper(wait)
+      if wait.is_a?(Range)
+        ms = rand(wait.last * 1000).to_f 
+        ms = wait.first if ms < wait.first
+      else
+        ms = wait * 1000
+      end
+      sleep ms / 1000
+    end
+    
+    def generate_http_client
+      if @proxy
+        http_client = HTTPClient.new(@proxy.uri)
+        http_client.set_proxy_auth(@proxy.user, @proxy.pass) if @proxy.user
+      else
+        http_client = HTTPClient.new
+      end
+      http_client.set_cookie_store @cookie_file.to_s
+      http_client
+    end
+    
+    def prepare_params(usecase, params)
+      newparams = {}
+      params.each_pair do |n,v|
+        v = usecase.instance_eval &v if v.is_a?(Proc)
+        newparams[n] = v
+      end
+      newparams
+    end
+    
+    # Testplan URIs can be relative or absolute. Either one can
+    # contain variables in the form <tt>:varname</tt>, as in:
+    #
+    #     http://example.com/product/:productid
+    # 
+    # This method creates a new URI object using the @base_uri
+    # if necessary and replaces all variables with literal values.
+    # If no replacement value can be found, the variable is not touched. 
+    def build_request_uri(requri, params, container)
+      uri = ""
+      request_uri = requri.to_s
+      if requri.host.nil?
+        uri = base_uri.to_s
+        uri.gsub! /\/$/, ''  # Don't double up on the first slash
+        request_uri = '/' << request_uri unless request_uri.match(/^\//)
+      end
+      # We call req.uri again because we need  
+      # to modify request_uri inside the loop. 
+      requri.to_s.scan(/:([a-z_]+)/i) do |instances|
+        instances.each do |varname|
+          val = find_replacement_value(varname, params, container)
+          #Stella.ld "FOUND: #{val}"
+          request_uri.gsub! /:#{varname}/, val.to_s unless val.nil?
+        end
+      end
+      uri << request_uri
+      URI.parse uri
+    end
+    
+    # Testplan URIs can contain variables in the form <tt>:varname</tt>. 
+    # This method looks at the request parameters and then at the 
+    # usecase's resource hash for a replacement value. 
+    # If not found, returns nil. 
+    def find_replacement_value(name, params, container)
+      value = nil
+      #Stella.ld "REPLACE: #{name}"
+      #Stella.ld "PARAMS: #{params.inspect}"
+      #Stella.ld "IVARS: #{container.instance_variables}"
+      value = params[name.to_sym] 
+      value = container.resource name.to_sym if value.nil?
+      value
+    end 
+    
+    # Find the appropriate response handler by executing the
+    # HTTP response status against the configured handlers. 
+    # If several match, the first one is used. 
+    def execute_response_handler(container, req)
+      handlers = req.response.select do |regex,handler|
+        regex = /#{regex}/ unless regex.is_a? Regexp
+        Stella.ld "HANDLER REGEX: #{regex} (#{container.status})"
+        container.status.to_s =~ regex
+      end
+      ret = nil
+      unless handlers.empty?
+        begin
+          changed
+          ret = container.instance_eval &handlers.values.first
+          notify_observers(:execute_response_handler, @client_id, req, container)
+        rescue => ex
+          notify_observers(:error_execute_response_handler, @client_id, ex, req, container)
+          Stella.ld ex.message, ex.backtrace
+        end
+      end
+      ret
+    end
+    
+    class Container
+      attr_accessor :usecase
+      attr_accessor :response
+      def initialize(usecase)
+        @usecase = usecase
+      end
+      
+      def doc
+        # NOTE: It's important to parse the document on every 
+        # request because this container is available for the
+        # entire life of a usecase. 
+        case @response.header['Content-Type']
+        when ['text/html']
+          Nokogiri::HTML(body)
+        when ['text/yaml']
+          YAML.load(body)
+        end
+      end
+
+      def body; @response.body.content; end
+      def headers; @response.header; end
+        alias_method :header, :headers
+      def status; @response.status; end
+      def set(n, v); usecase.resource n, v; end
+      def resource(n);    usecase.resource n;    end
+      def wait(t); sleep t; end
+      
+      def repeat(t=1); Repeat.new(t); end
+    end
+    
+    class ResponseModifier; end
+    class Repeat < ResponseModifier; 
+      attr_accessor :times
+      def initialize(times)
+        @times = times
+      end
+    end
+  end
+end

data/lib/stella/config.rb

@@ -0,0 +1,87 @@
+
+
+class Stella::Config < Storable
+  include Gibbler::Complex
+
+  field :source
+  field :apikey
+  field :secret
+    
+   # Returns true when the current config matches the default config
+  def default?; to_hash.gibbler == DEFAULT_CONFIG_HASH; end
+  
+  def self.each_path(&blk)
+    [PROJECT_PATH, USER_PATH].each do |path|
+      Stella.ld "Loading #{path}"
+      blk.call(path) if File.exists? path
+    end
+  end
+  
+  def self.refresh
+    conf = {}
+    Stella::Config.each_path do |path| 
+      tmp = YAML.load_file path
+      conf.merge! tmp if tmp
+    end
+    from_hash conf
+  end
+  
+  def self.init
+    raise AlreadyInitialized, PROJECT_PATH if File.exists? PROJECT_PATH
+    dir = File.dirname USER_PATH
+    Dir.mkdir(dir, 0700) unless File.exists? dir
+    unless File.exists? USER_PATH
+      Stella.li "Creating #{USER_PATH} (Add your credentials here)"
+      Stella::Utils.write_to_file(USER_PATH, DEFAULT_CONFIG, 'w', 0600)
+    end
+    
+    dir = File.dirname PROJECT_PATH
+    Dir.mkdir(dir, 0700) unless File.exists? dir
+    
+    Stella.li "Creating #{PROJECT_PATH}"
+    Stella::Utils.write_to_file(PROJECT_PATH, 'target:', 'w', 0600)
+  end
+  
+  def self.blast
+    if File.exists? USER_PATH
+      Stella.li "Blasting #{USER_PATH}"
+      FileUtils.rm_rf File.dirname(USER_PATH)
+    end
+    if File.exists? PROJECT_PATH
+      Stella.li "Blasting #{PROJECT_PATH}"
+      FileUtils.rm_rf File.dirname(PROJECT_PATH)
+    end
+  end
+ 
+  
+  private 
+  
+  def self.find_project_config
+    dir = Dir.pwd.split File::SEPARATOR
+    path = nil
+    while !dir.empty?
+      tmp = File.join(dir.join(File::SEPARATOR), DIR_NAME, 'config')
+      Stella.ld " -> looking for #{tmp}"
+      path = tmp and break if File.exists? tmp
+      dir.pop
+    end
+    path ||= File.join(Dir.pwd, DIR_NAME, 'config')
+    path
+  end
+  
+  
+  unless defined?(DIR_NAME)
+    DIR_NAME = Stella.sysinfo.os == :windows ? 'Stella' : '.stella'
+    USER_PATH = File.join(Stella.sysinfo.home, DIR_NAME, 'config')
+    PROJECT_PATH = Stella::Config.find_project_config
+    DEFAULT_CONFIG = <<CONF
+apikey: ''
+secret: ''
+remote: stella.solutious.com:443
+CONF
+    DEFAULT_CONFIG_HASH = YAML.load(DEFAULT_CONFIG).gibbler
+  end
+    
+  class AlreadyInitialized < Stella::Error; end
+end
+

data/lib/stella/data/http/body.rb

@@ -0,0 +1,15 @@
+module Stella::Data::HTTP
+  class Body < Storable
+    include Gibbler::Complex
+    
+    field :content_type
+    field :form_param
+    field :content
+    
+    def has_content?
+      !@content.nil?
+    end
+    
+  end
+  
+end

data/lib/stella/data/http/request.rb

@@ -0,0 +1,116 @@
+
+
+module Stella::Data::HTTP
+  class Request < Storable
+    include Gibbler::Complex
+    include Stella::Data::Helpers
+    
+    # A hash containing blocks to be executed depending on the HTTP response status.
+    # The hash keys are numeric HTTP Status Codes. 
+    #
+    #     200 => { ... }
+    #     304 => { ... }
+    #     500 => { ... }
+    #
+    attr_accessor :response_handler
+    
+    field :desc
+    field :header 
+    field :uri
+    field :wait
+    field :params
+    field :body 
+    field :http_method
+    field :http_version
+    field :content_type
+    
+    def has_body?
+      !@body.nil? && !@body.empty?
+    end
+    
+    def initialize (method, uri_str, version="1.1", &definition)
+      @uri = uri_str
+      @http_method, @http_version = method, version
+      @headers, @params, @response_handler = {}, {}, {}
+      @wait = 0
+      @desc = "Request"
+      @body = Stella::Data::HTTP::Body.new
+      instance_eval &definition unless definition.nil?
+    end
+    
+    def desc(*args)
+      @desc = args.first unless args.empty?
+      @desc
+    end
+    
+    def content_type(*args)
+      @content_type = args.first unless args.empty?
+      @content_type
+    end
+    
+    def wait(*args)
+      @wait = args.first unless args.empty?
+      @wait
+    end
+    alias_method :sleep, :wait
+    
+    def headers(*args)
+      @headers.merge! args.first unless args.empty?
+      @headers
+    end
+    alias_method :header, :headers
+    
+    def params(*args)
+      @params.merge! args.first unless args.empty?
+      @params
+    end
+    alias_method :param, :params
+    
+    def response(*args, &definition)
+      if definition.nil?
+        @response_handler
+      else
+        args << 200 if args.empty?
+        args.each do |status|
+          @response_handler[status] = definition
+        end
+      end
+    end
+    
+    # +content+ can be literal content or a file path
+    def body(*args)
+      return @body if args.empty?
+      content, form_param, content_type = *args
+      
+      @body.form_param = form_param if form_param
+      @body.content_type = content_type if content_type
+      
+      if File.exists?(content)
+        @body.content = File.new(content)
+        @body.content_type ||= "application/x-www-form-urlencoded"
+      else
+        @body.content = content
+      end
+      
+    end
+    
+    def inspect
+      str = "%s %s HTTP/%s" % [http_method, uri.to_s, http_version]
+      #str << $/ + headers.join($/) unless headers.empty?
+      #str << $/ + $/ + body.to_s if body
+      str
+    end
+    
+    def to_s
+      str = "%s %s HTTP/%s" % [http_method, uri.to_s, http_version]
+      str
+    end
+    
+    def cookies
+      return [] if !header.is_a?(Hash) || header[:Cookie].empty?
+      header[:Cookie] 
+    end
+    
+  end
+  
+end

data/lib/stella/data/http/response.rb

@@ -0,0 +1,92 @@
+
+
+module Stella::Data::HTTP
+  
+  class Response < Storable
+    include Gibbler::Complex
+    
+    attr_reader :raw_data
+    
+    field :time => DateTime
+    field :client_ip => String
+    field :server_ip => String
+    field :header => String
+    field :body => String
+    field :status => String
+    field :message => String
+    field :http_version => String
+    
+    def initialize(raw_data=nil)
+      @raw_data = raw_data
+      parse(@raw_data)
+    end
+    
+    def parse(raw)
+      return unless raw
+      @status, @http_version, @message, @header, @body = HTTPUtil::parse_http_response(raw)
+    end
+    
+    def has_body?
+      !@body.nil? && !@body.empty?
+    end
+    def has_request?
+      false
+    end
+    def has_response?
+      false
+    end
+    
+    
+    def body
+      return nil unless @body
+      #TODO: Move to HTTPResponse::Body.to_s
+      if is_binary?
+       "[skipping binary content]"
+      elsif is_gzip?
+        #require 'zlib'
+        #Zlib::Inflate.inflate(@body)
+         "[skipping gzip content]"
+      else
+        @body
+      end
+    end
+    
+    def headers
+      headers = []
+      header.each_pair do |n,v|
+        headers << [n.to_s.gsub('_', '-'), v[0]]
+      end
+      headers
+    end
+    
+    def is_binary?
+      (!is_text?) == true
+    end
+    
+    def is_text?
+      (!header[:Content_Type].nil? && (header[:Content_Type][0].is_a? String) && header[:Content_Type][0][/text/] != nil)
+    end
+    
+    def is_gzip?
+      (!header[:Content_Encoding].nil? && (header[:Content_Encoding][0].is_a? String) && header[:Content_Encoding][0][/gzip/] != nil)
+    end
+    
+    def inspect
+      str = "HTTP/%s %s (%s)" % [@http_version, @status, @message]
+      str << $/ + headers.join($/)
+      str << $/ + $/ + body if body
+      str
+    end
+    
+    def to_s
+      str = "%s: HTTP/%s %s (%s)" % [time.strftime(NICE_TIME_FORMAT), @http_version, @status, @message]
+      str 
+    end
+    
+    
+    def cookies
+      return [] unless header.is_a?(Array) && !header[:Set_Cookie].empty?
+      header[:Set_Cookie] 
+    end
+  end
+end