stella 0.5.5 → 0.6.0

data/lib/stella/test/definition.rb

@@ -1,79 +0,0 @@
-
-
-module Stella
-  
-
-  module Test
-    
-    # Stella::Test::Definition
-    # 
-    # This class defines the properties of load test. These are "generic" properties
-    # in that they don't relate to a specific tool.
-    class Definition
-      
-      # Stella::Test::Definition::Rampup
-      # 
-      # This class holds the values for a rampup: interval and ceiling.
-      class Rampup
-        attr_accessor :interval
-        attr_accessor :ceiling
-        def initialize(interval, ceiling)
-          @interval = interval
-          @ceiling = ceiling
-        end
-        def to_s
-          to_a.join(',')
-        end
-        def to_a
-          [interval,ceiling]
-        end
-      end
-      
-        # Number of virtual users to create or to begin with if rampup is specific.
-      attr_accessor :vusers 
-        # The total number of requests per test
-      attr_accessor :requests 
-        # The number of requests per virtual user
-      attr_accessor :request_ratio
-    
-        # Number of times to repeat the test run. Integer.
-      attr_reader :repetitions
-        # The amount of time to pause between test runs
-      attr_accessor :sleep
-        # Warmup factor (0.1 - 1) for a single test run before the actual test. 
-        # A warmup factor of 0.5 means run a test run at 50% strength. 
-      attr_accessor :warmup
-        # Contains an interval and maximum threshold to increase virtual users. 
-        # Rampup object, or Array like [R,M] where R is the interval and M is the maximum. 
-      attr_reader :rampup
-        # An array of string appropriate for a User-Agent HTTP header
-      attr_accessor :agents
-        # A short reminder to yourself what you're testing 
-      attr_accessor :message
-    
-      def initialize  
-        @repetitions = 3
-      end
-      
-      def repetitions=(v)
-        return unless v && v > 0
-        @repetitions = v
-      end
-      
-      def rampup=(v)
-        return unless v
-        
-        if (v.is_a? Rampup)
-          @rampup = v
-        elsif (v.is_a?(Array) && v.size == 2)
-          @rampup = Rampup.new(v[0], v[1])
-        else
-          raise UnknownValue.new(v.to_s)
-        end
-      end
-      
-    end
-  end
-  
-end
-

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

@@ -1,70 +0,0 @@
-
-
-
-module Stella::Test::Run
-
-  class Summary < Stella::Storable
-    attr_accessor :format
-    
-    field :availability => Float
-    field :transactions => Integer
-    field :elapsed_time => Float
-    field :data_transferred => Float
-    field :headers_transferred => Float 
-    field :response_time => Float
-    field :transaction_rate => Float
-    field :throughput => Float
-    field :vusers => Integer
-    field :successful => Integer
-    field :failed => Integer
-    field :note => String
-    field :raw => String
-    field :tool => String
-    field :version => String
-
-    def initialize(note="")
-      #init
-      @note = note
-      reset
-    end
-    
-    def reset
-      @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
-      begin
-        (@transactions / @successful).to_f * 100
-      rescue => ex
-        return 0.0
-      end
-    end
-    
-    # We calculate the throughput because Apache Bench does not provide this
-    # value in the output. 
-    def throughput
-      begin
-        return (@data_transferred / @elapsed_time).to_f
-      rescue => ex
-        return 0.0
-      end
-    end
-    
-
-    
-    def available?
-      @successful && @transactions && @elapsed_time && @vusers && @response_time
-    end
-    
-  end
-  
-  
-end

data/lib/stella/test/stats.rb

@@ -1,114 +0,0 @@
-
-
-module Stella::Test
-  
-  # Stella::Test::Stats
-  class Stats < Stella::Storable
-
-    field :elapsed_time_avg => Float
-    field :transaction_rate_avg => Float
-    field :vusers_avg => Float
-    field :response_time_avg => Float
-
-    field :elapsed_time_sdev => Float
-    field :transaction_rate_sdev => Float
-    field :vusers_sdev => Float
-    field :response_time_sdev => Float
-
-
-    field :transactions_total => Float
-    field :successful_total => Float
-    field :failed_total => Float
-
-    field :data_transferred_total => Float
-    field :headers_transferred_total => Float
-
-
-    field :elapsed_time_total => Float
-    field :availability => Float
-    field :throughput_avg => Float
-    field :throughput_sdev => Float
-    
-    def availability
-      return 0 if @successful_total == 0
-      begin
-        (@transactions_total / @successful_total).to_f * 100
-      rescue => ex
-        0.0
-      end
-    end
-    
-    
-    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 = ::Stats.new
-      transaction_rates = ::Stats.new
-      vusers_list = ::Stats.new
-      response_times = ::Stats.new
-      response_time = ::Stats.new
-      transaction_rate = ::Stats.new
-      throughput = ::Stats.new
-      vusers = ::Stats.new
-      
-      # 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 || 0
-        @headers_transferred_total += run.headers_transferred || 0
-        @data_transferred_total += run.data_transferred || 0
-        @successful_total += run.successful || 0
-        @failed_total += run.failed || 0
-        @elapsed_time_total += run.elapsed_time || 0
-        
-        # These are used for standard deviation
-        elapsed_times.sample(run.elapsed_time)
-        transaction_rates.sample(run.transaction_rate)
-        vusers_list.sample(run.vusers)
-        response_times.sample(run.response_time)
-        throughput.sample(run.throughput)
-        response_time.sample(run.response_time)
-        transaction_rate.sample(run.transaction_rate)
-        vusers.sample(run.vusers)
-      end
-      
-      # Calculate Averages
-      @elapsed_time_avg = elapsed_times.mean
-      @throughput_avg = throughput.mean
-      @response_time_avg = response_time.mean
-      @transaction_rate_avg = transaction_rate.mean
-      @vusers_avg = vusers.mean 
-      
-      # Calculate Standard Deviations
-      @elapsed_time_sdev = elapsed_times.sd
-      @throughput_sdev= throughput.sd
-      @transaction_rate_sdev = transaction_rates.sd
-      @vusers_sdev = vusers_list.sd
-      @response_time_sdev = response_times.sd
-      
-    end
-  end
-  
-end

data/lib/stella/text.rb

@@ -1,64 +0,0 @@
-
-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

@@ -1,38 +0,0 @@
-
-
-module Stella
-  
-  class Text
-    class Resource
-      require 'yaml'
-      
-      attr_reader :lang, :country, :encoding
-      
-      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

@@ -1,84 +0,0 @@
-# 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