solutious-stella 0.5.5

data/lib/stella/test/definition.rb

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

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

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

@@ -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,38 @@
+
+
+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

@@ -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