stella 0.3.2

data/lib/stella/test/run/summary.rb

@@ -0,0 +1,50 @@
+
+
+
+module Stella::Test::Run
+
+  class Summary < Stella::Storable
+    
+    attr_accessor :note
+    attr_accessor :tool, :version
+    attr_accessor :test, :transactions, :headers_transferred
+    attr_accessor :elapsed_time, :data_transferred, :response_time
+    attr_accessor :successful, :failed, :transaction_rate, :vusers, :raw
+    
+    def initialize(note="")
+      @note = note
+      @transactions = 0
+      @headers_transferred = 0
+      @elapsed_time = 0
+      @data_transferred = 0
+      @response_time = 0
+      @successful = 0
+      @failed = 0
+      @transaction_rate = 0
+      @vusers = 0
+    end
+    
+    def availability
+      return 0 if @successful == 0
+      (@transactions / @successful).to_f * 100
+    end
+    
+    # We calculate the throughput because Apache Bench does not provide this
+    # value in the output. 
+    def throughput
+      return 0 if !@elapsed_time || @elapsed_time == 0
+      (@data_transferred / @elapsed_time).to_f
+    end
+    
+    def field_names
+      [
+        :availability, :transactions, :elapsed_time, :data_transferred,
+        :headers_transferred, :response_time, :transaction_rate, :throughput,
+        :vusers, :successful, :failed, :note
+      ]
+    end
+    
+  end
+  
+  
+end

data/lib/stella/test/summary.rb

@@ -0,0 +1,82 @@
+
+require 'stella/test/base'
+
+module Stella::Test
+  
+  # Stella::Test::Summary
+  class Summary < Stella::Storable
+    include Base
+    
+    attr_reader :runs
+    
+    def initialize(msg="")
+      @message = msg
+      @runs = []
+    end
+    
+    # Add a TestRun object to the list
+    def add_run(run)
+      raise "I got a #{run.class} but I wanted a Run::Summary" unless run.is_a?(Run::Summary)
+      @runs << run
+      calculate
+    end
+    
+    private 
+    def calculate
+      # We simply keep a running tally of these
+      @transactions_total = 0
+      @headers_transferred_total = 0
+      @data_transferred_total = 0
+      @elapsed_time_total = 0
+      @successful_total = 0
+      @failed_total = 0
+      
+      # We keep a list of the values for averaging and std dev
+      elapsed_times = []
+      transaction_rates = []
+      vusers_list = []
+      response_times = []
+      response_time = []
+      transaction_rate = []
+      throughput = []
+      vusers = []
+      
+      # Each run is the summary of a single run (i.e. run01/SUMMARY.csv)
+      runs.each do |run|
+        # These are totaled
+        @transactions_total += run.transactions
+        @headers_transferred_total += run.headers_transferred
+        @data_transferred_total += run.data_transferred
+        @successful_total += run.successful
+        @failed_total += run.failed
+        @elapsed_time_total += run.elapsed_time
+        
+        # These are used for standard deviation
+        elapsed_times << run.elapsed_time
+        transaction_rates << run.transaction_rate
+        vusers_list << run.vusers
+        response_times << run.response_time
+        throughput << run.throughput
+        response_time << run.response_time
+        transaction_rate << run.transaction_rate
+        vusers << run.vusers
+      end
+      
+      # Calculate Averages
+      @elapsed_time_avg = elapsed_times.average
+      @throughput_avg = throughput.average
+      @response_time_avg = response_time.average
+      @transaction_rate_avg = transaction_rate.average
+      @vusers_avg = vusers.average 
+      
+      # Calculate Standard Deviations
+      @elapsed_time_sdev = elapsed_times.standard_deviation
+      @throughput_sdev= throughput.standard_deviation
+      @transaction_rate_sdev = transaction_rates.standard_deviation
+      @vusers_sdev = vusers_list.standard_deviation
+      @response_time_sdev = response_times.standard_deviation
+      
+    end
+  end
+  
+end

data/lib/stella/text.rb

@@ -0,0 +1,64 @@
+
+module Stella
+  
+  # Stella::Text
+  #
+  # This is the API for retrieving interface text in Stella. The intended use
+  # is to have a single instance of this class although there's nothing stopping
+  # you (or anyone else!) from having as many instances as you see fit. 
+  # Currently only yaml files are supported. 
+  class Text
+    require 'stella/text/resource'
+    
+    DEFAULT_LANGUAGE = 'en'.freeze unless defined? LANGUAGE
+    MESSAGE_NOT_DEFINED = "The message %s is not defined"
+    RESOURCES_PATH = File.join(STELLA_HOME, "support", "text").freeze unless defined? RESOURCES_PATH
+    
+    attr_reader :resource, :lang
+    
+    def initialize(language=nil)
+      @lang = determine_language(language)
+      @resource = Resource.new(RESOURCES_PATH, @lang)
+      @available_languages = []
+    end
+    
+    def determine_language(language)
+      return language if Text.supported_language?(language)
+      Stella::LOGGER.info("There's no translation for '#{language}' yet. Maybe you can help? stella@solutious.com") if language
+      language = (ENV['STELLA_LANG'] || ENV['LOCALE'] || '').split('_')[0]
+      Text.supported_language?(language) ? language : DEFAULT_LANGUAGE
+    end
+    
+    def msg(txtsym, *vars)
+      return self.parse(MESSAGE_NOT_DEFINED, txtsym) unless @resource.message.has_key?(txtsym)
+      parse(@resource.message[txtsym], vars)
+    end
+
+    def err(txtsym, *vars)
+      return self.parse(MESSAGE_NOT_DEFINED, txtsym) unless @resource.error.has_key?(txtsym)
+      parse(@resource.error[txtsym], vars)
+    end
+
+    def parse(text, vars)
+      sprintf(text, *vars)
+    end
+    
+    def self.supported_language?(language)
+      return File.exists?(File.join(RESOURCES_PATH, "#{language}.yaml"))
+    end
+    
+    def available_languages
+      #return @available_languages unless @available_languages.empty?
+      translations = Dir.glob(File.join(RESOURCES_PATH, "*.yaml"))
+      translations.each do |path|
+        trans = YAML.load_file(path)
+        next if !trans || trans.empty? || !trans[:info] || !trans[:info][:enabled]
+        @available_languages << trans[:info]
+      end
+      @available_languages
+    end
+    
+  end
+  
+  
+end

data/lib/stella/text/resource.rb

@@ -0,0 +1,39 @@
+
+
+module Stella
+  
+  class Text
+    class Resource
+      require 'yaml'
+      
+      attr_reader :lang, :country, :encoding
+      attr_reader :messages, :path
+      
+      def initialize(path, lang)
+        @path = path
+        @lang = lang
+        @messages = {}
+        load_resource
+      end
+      
+      def path
+        File.join(@path, "#{@lang}.yaml")
+      end
+      
+      def load_resource
+        return @messages unless @messages.empty?
+        Stella::LOGGER.debug("LOADING #{path}")
+        raise UnsupportedLanguage unless File.exists?(path)
+        @messages = YAML.load_file(path)
+      end
+      
+      def messages
+        @messages
+      end
+        alias :message :messages
+        alias :error :messages
+      
+    end
+  end
+  
+end

data/lib/utils/crypto-key.rb

@@ -0,0 +1,84 @@
+# based on: http://blog.leetsoft.com/2006/03/14/simple-encryption
+
+
+require 'base64'  # Added, to fix called to Base64
+
+# IF NOT JRUBY
+require 'openssl'
+# ELSE
+#module JRuby
+#   module OpenSSL
+#     GEM_ONLY = false unless defined?(GEM_ONLY)
+#   end
+# end
+#
+# if JRuby::OpenSSL::GEM_ONLY
+#   require 'jruby/openssl/gem'
+# else
+#   module OpenSSL
+#     class OpenSSLError < StandardError; end
+#     # These require the gem
+#     %w[
+#     ASN1
+#     BN
+#     Cipher
+#     Config
+#     Netscape
+#     PKCS7
+#     PKey
+#     Random
+#     SSL
+#     X509
+#     ].each {|c| autoload c, "jruby/openssl/gem"}
+#   end
+#   require "jruby/openssl/builtin"
+# end
+#end
+ 
+module Crypto
+  VERSION = 1.0
+  
+  def self.create_keys(bits = 2048)
+    pk = OpenSSL::PKey::RSA.new(bits)
+  end
+  
+  @@digest = OpenSSL::Digest::Digest.new("sha1")
+  def self.sign(secret, string)
+    sig = OpenSSL::HMAC.hexdigest(@@digest, secret, string).strip
+    #sig.gsub(/\+/, "%2b")
+  end
+  def self.aws_sign(secret, string)
+    Base64.encode64(self.sign(secret, string)).strip
+  end
+  
+  class Key
+    attr_reader :data, :key
+    
+    def initialize(data)
+      @data = data 
+      @public = (data =~ /^-----BEGIN (RSA|DSA) PRIVATE KEY-----$/).nil?
+      @key = OpenSSL::PKey::RSA.new(@data)
+    end  
+    
+    
+    def self.from_file(filename)    
+      self.new File.read( filename )
+    end
+  
+    def encrypt(text)
+      Base64.encode64(@key.send("#{type}_encrypt", text))
+    end
+    
+    def decrypt(text)
+      @key.send("#{type}_decrypt", Base64.decode64(text))
+    end
+  
+    def private?()  !@public; end # Added () and ;
+  
+    def public?()   @public;  end # Added () and ;
+    
+    def type
+      @public ? :public : :private
+    end
+  end
+end

data/lib/utils/escape.rb

@@ -0,0 +1,302 @@
+# escape.rb - escape/unescape library for several formats
+#
+# Copyright (C) 2006,2007 Tanaka Akira  <akr@fsij.org>
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+#  1. Redistributions of source code must retain the above copyright notice, this
+#     list of conditions and the following disclaimer.
+#  2. Redistributions in binary form must reproduce the above copyright notice,
+#     this list of conditions and the following disclaimer in the documentation
+#     and/or other materials provided with the distribution.
+#  3. The name of the author may not be used to endorse or promote products
+#     derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+# WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+# EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+# OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+# IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+# OF SUCH DAMAGE.
+
+# Escape module provides several escape functions.
+# * URI
+# * HTML
+# * shell command
+module EscapeUtil
+  module_function
+
+  class StringWrapper
+    class << self
+      alias new_no_dup new
+      def new(str)
+        new_no_dup(str.dup)
+      end
+    end
+
+    def initialize(str)
+      @str = str
+    end
+
+    def to_s
+      @str.dup
+    end
+
+    def inspect
+      "\#<#{self.class}: #{@str}>"
+    end
+
+    def ==(other)
+      other.class == self.class && @str == other.instance_variable_get(:@str)
+    end
+    alias eql? ==
+
+    def hash
+      @str.hash
+    end
+  end
+
+  class ShellEscaped < StringWrapper
+  end
+
+  # Escape.shell_command composes
+  # a sequence of words to
+  # a single shell command line.
+  # All shell meta characters are quoted and
+  # the words are concatenated with interleaving space.
+  # It returns an instance of ShellEscaped.
+  #
+  #  Escape.shell_command(["ls", "/"]) #=> #<Escape::ShellEscaped: ls />
+  #  Escape.shell_command(["echo", "*"]) #=> #<Escape::ShellEscaped: echo '*'>
+  #
+  # Note that system(*command) and
+  # system(Escape.shell_command(command)) is roughly same.
+  # There are two exception as follows.
+  # * The first is that the later may invokes /bin/sh.
+  # * The second is an interpretation of an array with only one element: 
+  #   the element is parsed by the shell with the former but
+  #   it is recognized as single word with the later.
+  #   For example, system(*["echo foo"]) invokes echo command with an argument "foo".
+  #   But system(Escape.shell_command(["echo foo"])) invokes "echo foo" command without arguments (and it probably fails).
+  def shell_command(command)
+    s = command.map {|word| shell_single_word(word) }.join(' ')
+    ShellEscaped.new_no_dup(s)
+  end
+
+  # Escape.shell_single_word quotes shell meta characters.
+  # It returns an instance of ShellEscaped.
+  #
+  # The result string is always single shell word, even if
+  # the argument is "".
+  # Escape.shell_single_word("") returns #<Escape::ShellEscaped: ''>.
+  #
+  #  Escape.shell_single_word("") #=> #<Escape::ShellEscaped: ''>
+  #  Escape.shell_single_word("foo") #=> #<Escape::ShellEscaped: foo>
+  #  Escape.shell_single_word("*") #=> #<Escape::ShellEscaped: '*'>
+  def shell_single_word(str)
+    if str && str.empty?
+      ShellEscaped.new_no_dup("''")
+    elsif %r{\A[0-9A-Za-z+,./:=@_-]+\z} =~ str
+      ShellEscaped.new(str)
+    else
+      result = ''
+      str.scan(/('+)|[^']+/) {
+        if $1
+          result << %q{\'} * $1.length
+        else
+          result << "'#{$&}'"
+        end
+      }
+      ShellEscaped.new_no_dup(result)
+    end
+  end
+
+  class PercentEncoded < StringWrapper
+  end
+
+  # Escape.uri_segment escapes URI segment using percent-encoding.
+  # It returns an instance of PercentEncoded.
+  #
+  #  Escape.uri_segment("a/b") #=> #<Escape::PercentEncoded: a%2Fb>
+  #
+  # The segment is "/"-splitted element after authority before query in URI, as follows.
+  #
+  #   scheme://authority/segment1/segment2/.../segmentN?query#fragment
+  #
+  # See RFC 3986 for details of URI.
+  def uri_segment(str)
+    # pchar - pct-encoded = unreserved / sub-delims / ":" / "@"
+    # unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
+    # sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+    s = str.gsub(%r{[^A-Za-z0-9\-._~!$&'()*+,;=:@]}n) {
+      '%' + $&.unpack("H2")[0].upcase
+    }
+    PercentEncoded.new_no_dup(s)
+  end
+
+  # Escape.uri_path escapes URI path using percent-encoding.
+  # The given path should be a sequence of (non-escaped) segments separated by "/".
+  # The segments cannot contains "/".
+  # It returns an instance of PercentEncoded.
+  #
+  #  Escape.uri_path("a/b/c") #=> #<Escape::PercentEncoded: a/b/c>
+  #  Escape.uri_path("a?b/c?d/e?f") #=> #<Escape::PercentEncoded: a%3Fb/c%3Fd/e%3Ff>
+  #
+  # The path is the part after authority before query in URI, as follows.
+  #
+  #   scheme://authority/path#fragment
+  #
+  # See RFC 3986 for details of URI.
+  #
+  # Note that this function is not appropriate to convert OS path to URI.
+  def uri_path(str)
+    s = str.gsub(%r{[^/]+}n) { uri_segment($&) }
+    PercentEncoded.new_no_dup(s)
+  end
+
+  # :stopdoc:
+  def html_form_fast(pairs, sep='&')
+    s = pairs.map {|k, v|
+      # query-chars - pct-encoded - x-www-form-urlencoded-delimiters =
+      #   unreserved / "!" / "$" / "'" / "(" / ")" / "*" / "," / ":" / "@" / "/" / "?"
+      # query-char - pct-encoded = unreserved / sub-delims / ":" / "@" / "/" / "?"
+      # query-char = pchar / "/" / "?" = unreserved / pct-encoded / sub-delims / ":" / "@" / "/" / "?"
+      # unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
+      # sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+      # x-www-form-urlencoded-delimiters = "&" / "+" / ";" / "="
+      k = k.gsub(%r{[^0-9A-Za-z\-\._~:/?@!\$'()*,]}n) {
+        '%' + $&.unpack("H2")[0].upcase
+      }
+      v = v.gsub(%r{[^0-9A-Za-z\-\._~:/?@!\$'()*,]}n) {
+        '%' + $&.unpack("H2")[0].upcase
+      }
+      "#{k}=#{v}"
+    }.join(sep)
+    PercentEncoded.new_no_dup(s)
+  end
+  # :startdoc:
+
+  # Escape.html_form composes HTML form key-value pairs as a x-www-form-urlencoded encoded string.
+  # It returns an instance of PercentEncoded.
+  #
+  # Escape.html_form takes an array of pair of strings or
+  # an hash from string to string.
+  #
+  #  Escape.html_form([["a","b"], ["c","d"]]) #=> #<Escape::PercentEncoded: a=b&c=d>
+  #  Escape.html_form({"a"=>"b", "c"=>"d"}) #=> #<Escape::PercentEncoded: a=b&c=d>
+  #
+  # In the array form, it is possible to use same key more than once.
+  # (It is required for a HTML form which contains
+  # checkboxes and select element with multiple attribute.)
+  #
+  #  Escape.html_form([["k","1"], ["k","2"]]) #=> #<Escape::PercentEncoded: k=1&k=2>
+  #
+  # If the strings contains characters which must be escaped in x-www-form-urlencoded,
+  # they are escaped using %-encoding.
+  #
+  #  Escape.html_form([["k=","&;="]]) #=> #<Escape::PercentEncoded: k%3D=%26%3B%3D>
+  #
+  # The separator can be specified by the optional second argument.
+  #
+  #  Escape.html_form([["a","b"], ["c","d"]], ";") #=> #<Escape::PercentEncoded: a=b;c=d>
+  #
+  # See HTML 4.01 for details.
+  def html_form(pairs, sep='&')
+    r = ''
+    first = true
+    pairs.each {|k, v|
+      # query-chars - pct-encoded - x-www-form-urlencoded-delimiters =
+      #   unreserved / "!" / "$" / "'" / "(" / ")" / "*" / "," / ":" / "@" / "/" / "?"
+      # query-char - pct-encoded = unreserved / sub-delims / ":" / "@" / "/" / "?"
+      # query-char = pchar / "/" / "?" = unreserved / pct-encoded / sub-delims / ":" / "@" / "/" / "?"
+      # unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
+      # sub-delims = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+      # x-www-form-urlencoded-delimiters = "&" / "+" / ";" / "="
+      r << sep if !first
+      first = false
+      k.each_byte {|byte|
+        ch = byte.chr
+        if %r{[^0-9A-Za-z\-\._~:/?@!\$'()*,]}n =~ ch
+          r << "%" << ch.unpack("H2")[0].upcase
+        else
+          r << ch
+        end
+      }
+      r << '='
+      v.each_byte {|byte|
+        ch = byte.chr
+        if %r{[^0-9A-Za-z\-\._~:/?@!\$'()*,]}n =~ ch
+          r << "%" << ch.unpack("H2")[0].upcase
+        else
+          r << ch
+        end
+      }
+    }
+    PercentEncoded.new_no_dup(r)
+  end
+
+  class HTMLEscaped < StringWrapper
+  end
+
+  # :stopdoc:
+  HTML_TEXT_ESCAPE_HASH = {
+    '&' => '&amp;',
+    '<' => '&lt;',
+    '>' => '&gt;',
+  }
+  # :startdoc:
+
+  # Escape.html_text escapes a string appropriate for HTML text using character references.
+  # It returns an instance of HTMLEscaped.
+  #
+  # It escapes 3 characters:
+  # * '&' to '&amp;'
+  # * '<' to '&lt;'
+  # * '>' to '&gt;'
+  #
+  #  Escape.html_text("abc") #=> #<Escape::HTMLEscaped: abc>
+  #  Escape.html_text("a & b < c > d") #=> #<Escape::HTMLEscaped: a &amp; b &lt; c &gt; d>
+  #
+  # This function is not appropriate for escaping HTML element attribute
+  # because quotes are not escaped.
+  def html_text(str)
+    s = str.gsub(/[&<>]/) {|ch| HTML_TEXT_ESCAPE_HASH[ch] }
+    HTMLEscaped.new_no_dup(s)
+  end
+
+  # :stopdoc:
+  HTML_ATTR_ESCAPE_HASH = {
+    '&' => '&amp;',
+    '<' => '&lt;',
+    '>' => '&gt;',
+    '"' => '&quot;',
+  }
+  # :startdoc:
+
+  class HTMLAttrValue < StringWrapper
+  end
+
+  # Escape.html_attr_value encodes a string as a double-quoted HTML attribute using character references.
+  # It returns an instance of HTMLAttrValue.
+  #
+  #  Escape.html_attr_value("abc") #=> #<Escape::HTMLAttrValue: "abc">
+  #  Escape.html_attr_value("a&b") #=> #<Escape::HTMLAttrValue: "a&amp;b">
+  #  Escape.html_attr_value("ab&<>\"c") #=> #<Escape::HTMLAttrValue: "ab&amp;&lt;&gt;&quot;c">
+  #  Escape.html_attr_value("a'c") #=> #<Escape::HTMLAttrValue: "a'c">
+  #
+  # It escapes 4 characters:
+  # * '&' to '&amp;'
+  # * '<' to '&lt;'
+  # * '>' to '&gt;'
+  # * '"' to '&quot;'
+  #
+  def html_attr_value(str)
+    s = '"' + str.gsub(/[&<>"]/) {|ch| HTML_ATTR_ESCAPE_HASH[ch] } + '"'
+    HTMLAttrValue.new_no_dup(s)
+  end
+end