rhoconnect 3.0.0.beta1

data/bench/blobapp/sources/blob_adapter.rb

@@ -0,0 +1,71 @@
+class BlobAdapter < SourceAdapter
+  def initialize(source) 
+    super(source)
+  end
+ 
+  def login
+    # TODO: Login to your data source here if necessary
+    true
+  end
+ 
+  def query(params=nil)
+    Store.lock(lock_name,1) do
+      @result = Store.get_data(db_name)
+    end
+    @result   
+  end
+ 
+  def sync
+    # Manipulate @result before it is saved, or save it 
+    # yourself using the Rhoconnect::Store interface.
+    # By default, super is called below which simply saves @result
+    super
+  end
+ 
+  def create(create_hash)
+    file_name = create_hash['filename']    
+    if file_name
+      path_to_img_file = create_hash['image_uri']
+      # Simple verification that image successfully uploaded 
+      expected_size, actual_size = create_hash["img_file_size"].to_i, File.size(path_to_img_file) 
+      raise "BlobAdapter#create: expected image size #{expected_size}, but actual is #{actual_size}" if expected_size != actual_size
+
+      # Adjust create_hash to match expected md 
+      create_hash['img_file-rhoblob'] = file_name
+      create_hash.delete('image_uri')   
+    end
+
+    id = create_hash['mock_id']
+    Store.lock(lock_name,1) do
+      Store.put_data(db_name,{id => create_hash}, true) if id
+    end
+    id
+  end
+ 
+  def update(update_hash)
+    # TODO: Update an existing record in your backend data source
+    raise "Please provide some code to update a single record in the backend data source using the update_hash"
+  end
+ 
+  def delete(delete_hash)
+    # TODO: write some code here if applicable
+    # be sure to have a hash key and value for "object"
+    # for now, we'll say that its OK to not have a delete operation
+    # raise "Please provide some code to delete a single object in the backend application using the object_id"
+  end
+ 
+  def logoff
+    # TODO: Logout from the data source if necessary
+  end
+
+  private
+  
+  def db_name
+    "test_db_storage:#{@source.app_id}:#{@source.user_id}"
+  end
+  
+  def lock_name
+    "lock:#{db_name}"
+  end
+
+end

data/bench/blobapp/spec/sources/blob_adapter_spec.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+
+describe "BlobAdapter" do
+  it_should_behave_like "SpecHelper" do
+    before(:each) do
+      setup_test_for BlobAdapter,'testuser'
+    end
+
+    it "should process BlobAdapter query" do
+      pending
+    end
+
+    it "should process BlobAdapter create" do
+      pending
+    end
+
+    it "should process BlobAdapter update" do
+      pending
+    end
+
+    it "should process BlobAdapter delete" do
+      pending
+    end
+  end  
+end

data/bench/blobapp/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+require 'rubygems'
+
+# Set environment to test
+ENV['RHO_ENV'] = 'test'
+ROOT_PATH = File.expand_path(File.join(File.dirname(__FILE__),'..'))
+Bundler.require(:default, ENV['RHO_ENV'].to_sym)
+
+# Try to load vendor-ed rhoconnect, otherwise load the gem
+begin
+  require 'vendor/rhoconnect/lib/rhoconnect'
+rescue LoadError
+  require 'rhoconnect'
+end
+
+$:.unshift File.join(File.dirname(__FILE__), "..") # FIXME:
+# Load our rhoconnect application
+require 'application'
+include Rhoconnect
+
+require 'rhoconnect/test_methods'
+
+# Monkey patch to fix the following issue:
+# /Library/Ruby/Gems/1.8/gems/rspec-core-2.5.1/lib/rspec/core/shared_example_group.rb:45:
+# in `ensure_shared_example_group_name_not_taken': Shared example group '...' already exists (ArgumentError)
+module RSpec
+  module Core
+    module SharedExampleGroup
+    private
+      def ensure_shared_example_group_name_not_taken(name)
+      end
+    end
+  end
+end
+
+shared_examples_for "SpecHelper" do
+  include Rhoconnect::TestMethods
+  
+  before(:each) do
+    Store.db.flushdb
+    Application.initializer(ROOT_PATH)
+  end  
+end

data/bench/lib/bench/cli.rb

@@ -0,0 +1,16 @@
+require 'thor'
+
+module Bench
+  class Cli < Thor
+    include Logging
+    desc "start path/to/bench/script", "Start performance test"
+    def start(script,login,password='')
+      Bench.admin_login = login
+      Bench.admin_password = password
+      load(script)
+      Statistics.new(Bench.concurrency,Bench.iterations,
+        Bench.total_time,Bench.sessions).process.print_stats
+      bench_log "Bench completed..."
+    end
+  end
+end

data/bench/lib/bench/logging.rb

@@ -0,0 +1,13 @@
+module Bench
+  module Logging
+    def log_prefix
+      # FIXME: in ruby1.8:  "%d" % nil => 0
+      # but in ruby 1.9.2: TypeError: can't convert nil into Integer      
+      "[T:%03d|I:%03d]" % [@thread_id.to_i, @iteration.to_i]
+    end
+    
+    def bench_log(msg)
+      Rhoconnect.log msg
+    end
+  end
+end

data/bench/lib/bench/mock_client.rb

@@ -0,0 +1,41 @@
+require 'redis'
+$:.unshift File.join(File.dirname(__FILE__),'..','..','..','lib')
+require 'rhoconnect'
+include Rhoconnect
+  
+module Bench
+  class MockClient
+    include Logging
+        
+    def initialize(thread_id,iteration,client_id)
+      @thread_id,@iteration,@client_id = thread_id,iteration,client_id
+    end
+    
+    def parse(message)
+      msg = JSON.parse(message)
+      raise Exception.new("#{log_prefix} Wrong message format. Message: #{message.inspect}") if msg.size < 6
+      raise Exception.new("#{log_prefix} Wrong protocol version. Message: #{message.inspect}") if msg[0]['version'] != 3
+      msg.each do |p|
+        insert(p['insert']) if p['insert']
+        delete(p['delete']) if p['delete']
+      end
+    end
+    
+    def insert(objects)
+      Store.put_data(doc_type,objects,true)
+    end
+    
+    def delete(objects)
+      Store.delete_data(doc_type,objects)
+    end
+  
+    def verify(objects)
+      Store.get_data(doc_type) == objects
+    end
+      
+    def doc_type
+      "#{@client_id.to_s}:mock:cd"
+    end  
+
+  end
+end

data/bench/lib/bench/result.rb

@@ -0,0 +1,50 @@
+require 'set'
+
+module Bench
+  class Result
+    attr_accessor :last_response,:time,:marker,:url,:verb,:error,:verification_error
+    include Logging
+    include Utils
+    
+    def initialize(marker,verb,url,thread_id,iteration)
+      @marker,@verb,@url,@thread_id,@iteration = marker,verb,url,thread_id,iteration
+      @verification_error = 0
+      @time = 0
+    end
+    
+    def code
+      @last_response.code
+    end
+    
+    def body
+      @last_response.to_s
+    end
+    
+    def cookies
+      @last_response.cookies
+    end
+    
+    def headers
+      @last_response.headers
+    end
+    
+    def verify_body(expected)
+      expected,actual = JSON.parse(expected),JSON.parse(@last_response.to_s)    
+      @verification_error += compare_and_log(expected,actual,caller(1)[0].to_s)
+    end
+    
+    def verify_code(expected)
+      if expected != @last_response.code
+        bench_log "#{log_prefix} Verify error at: " + caller(1)[0].to_s
+        bench_log "#{log_prefix} Code diff: "
+        bench_log "#{log_prefix} expected: #{expected.inspect}"
+        bench_log "#{log_prefix} but got:  #{@last_response.code}"
+        @verification_error += 1
+      end
+    end
+    
+    def verify_headers
+      
+    end
+  end
+end

data/bench/lib/bench/runner.rb

@@ -0,0 +1,107 @@
+module Bench
+  class Runner
+    include Logging
+    include Timer
+    attr_reader :threads
+    
+    def initialize
+      @threads = []
+      @sessions = []
+    end
+
+    def test(concurrency,iterations,&block)
+      total_time = time do
+        0.upto(concurrency - 1) do |thread_id|
+          sleep rand(2)
+          threads << Thread.new(block) do |t|
+            0.upto(iterations - 1) do |iteration|
+              s = Session.new(thread_id, iteration)
+              @sessions << s
+              begin
+                yield Bench,s
+              rescue Exception => e
+                puts "error running script: #{e.inspect}"
+                puts e.backtrace.join("\n")
+              end
+            end
+          end
+        end
+        begin
+          threads.each { |t| t.join }
+        rescue RestClient::RequestTimeout => e
+          bench_log "Request timed out #{e}"
+        end
+      end
+      Bench.sessions = @sessions
+      Bench.total_time = total_time
+    end
+
+=begin
+    if defined?(JRUBY_VERSION)
+      def test(concurrency,iterations,&block)
+        total_time = time do
+          0.upto(concurrency - 1) do |thread_id|
+            sleep rand(2)                    
+            threads << Thread.new(block) do |t|
+              0.upto(iterations - 1) do |iteration|
+                s = Session.new(thread_id, iteration)
+                @sessions << s
+                begin
+                  yield Bench,s
+                rescue Exception => e
+                  puts "error running script: #{e.inspect}"
+                  puts e.backtrace.join("\n")
+                end
+              end
+            end
+          end
+          begin 
+            threads.each { |t| t.join }
+          rescue RestClient::RequestTimeout => e
+            bench_log "Request timed out #{e}"
+          end
+        end
+        Bench.sessions = @sessions
+        Bench.total_time = total_time
+      end      
+    else
+      def test(concurrency,iterations,&block)
+        total_time = time do
+          0.upto(concurrency - 1) do |thread_id|
+            sleep rand(2)                    
+            threads << Process.fork do
+              pid = $$ # child process id
+              0.upto(iterations - 1) do |iteration|
+                s = Session.new(thread_id, iteration)
+                begin
+                  yield Bench,s
+                rescue Exception => e
+                  puts "error running script: #{e.inspect}"
+                  puts e.backtrace.join("\n")
+                end
+                File.open("/tmp/runner_#{iteration}.#{pid}", "w+") { |f| Marshal.dump(s, f) }
+              end
+            end
+          end
+          begin 
+            @pid_stats = Process.waitall # returning an array of pid/status pairs
+          rescue RestClient::RequestTimeout => e
+            bench_log "Request timed out #{e}"
+          end
+        end
+        @pid_stats.each do |ps|
+          0.upto(iterations - 1) do |iteration|
+            filename = "/tmp/runner_#{iteration}.#{ps[0]}"
+            s = Marshal.load(File.open(filename))
+            @sessions << s
+            File.delete(filename)
+          end
+        end
+        Bench.sessions = @sessions
+        Bench.total_time = total_time
+      end
+    end
+=end
+
+  end
+end

data/bench/lib/bench/session.rb

@@ -0,0 +1,67 @@
+module Bench
+  class Session
+    include Logging
+    include Timer
+    attr_accessor :cookies, :last_result, :results, :thread_id, :iteration, :client_id
+    
+    def initialize(thread_id,iteration)
+      @cookies = {}
+      @results = {}
+      @thread_id,@iteration = thread_id,iteration
+    end
+      
+    def post(marker,url,headers={})
+      @body = yield
+      _request(marker,:_post,url,headers)
+    end
+    
+    def get(marker,url,headers={})
+      params = yield if block_given?
+      url_params = url.clone
+      url_params << "?" + _url_params(params) if params
+      _request(marker,:_get,url_params,headers)          
+    end
+    
+    protected
+    def _request(marker,verb,url,headers)
+      result = Result.new(marker,verb,url,@thread_id,@iteration)
+      @results[result.marker] ||= []
+      @results[result.marker] << result
+      begin
+        result.time = time do
+          headers.merge!(:cookies => @cookies)
+          result.last_response = send(verb,url,headers)
+          @last_result = result
+        end
+        bench_log "#{log_prefix} #{verb.to_s.upcase.gsub(/_/,'')} #{url} #{@last_result.code} #{result.time}"      
+      rescue RestClient::Exception => e
+        result.error = e
+        bench_log "#{log_prefix} #{verb.to_s.upcase.gsub(/_/,'')} #{url}"      
+        bench_log "#{log_prefix} #{e.http_code.to_s} #{e.message}\n"
+        raise e
+      end
+      @last_result.cookies['rhoconnect_session'] = 
+        CGI.escape(@last_result.cookies['rhoconnect_session']) if @last_result.cookies['rhoconnect_session']
+      @cookies = @cookies.merge(@last_result.cookies)
+      @last_result
+    end
+    
+    def _get(url,headers)
+      #bench_log "GET #{url}"
+      RestClient.get(url, headers)
+    end
+    
+    def _post(url,headers)
+      #bench_log "POST #{url}"
+      RestClient.post(url, @body, headers)
+    end
+    
+    def _url_params(params)
+      elements = []
+      params.each do |key,value|
+        elements << "#{key}=#{value}"
+      end
+      elements.join('&')
+    end
+  end
+end

data/bench/lib/bench/statistics.rb

@@ -0,0 +1,56 @@
+module Bench
+  class Statistics
+    include Logging
+    
+    def initialize(concurrency,iterations,total_time,sessions)
+      @sessions = sessions
+      @rows = {} # row key is result.marker;
+      @total_count = 0
+      @total_time = total_time
+      @concurrency,@iterations = concurrency,iterations
+    end
+    
+    def process
+      @sessions.each do |session|
+        session.results.each do |marker,results|
+          results.each do |result|
+            @rows[result.marker] ||= {}
+            row = @rows[result.marker]
+            row[:min] ||= 0.0
+            row[:max] ||= 0.0
+            row[:count] ||= 0
+            row[:total_time] ||= 0.0
+            row[:errors] ||= 0
+            row[:verification_errors] ||= 0
+            row[:min] = result.time if result.time < row[:min] || row[:min] == 0
+            row[:max] = result.time if result.time > row[:max]
+            row[:count] += 1.0
+            row[:total_time] += result.time            
+            row[:errors] += 1 if result.error
+            row[:verification_errors] += result.verification_error
+            @total_count += 1
+          end
+        end
+      end
+      self
+    end
+    
+    def average(row)
+      row[:total_time] / row[:count]
+    end
+    
+    def print_stats
+      bench_log "Statistics:"
+      @rows.each do |marker,row|
+        bench_log "Request %-15s: min: %0.4f, max: %0.4f, avg: %0.4f, err: %d, verification err: %d" % [marker, row[:min], row[:max], average(row), row[:errors], row[:verification_errors]]
+      end
+      bench_log "State of MD        : #{Bench.verify_error == 0 ? true : false}"
+      bench_log "Concurrency        : #{@concurrency}"
+      bench_log "Iterations         : #{@iterations}"
+      bench_log "Total Count        : #{@total_count}"
+      bench_log "Total Time         : #{@total_time}"
+      bench_log "Throughput(req/s)  : #{@total_count / @total_time}"
+      bench_log "Throughput(req/min): #{(@total_count / @total_time) * 60.0}"
+    end
+  end
+end

data/bench/lib/bench/test_data.rb

@@ -0,0 +1,98 @@
+require 'ffaker'
+require 'uuidtools'
+
+module Bench
+  module TestData
+    def get_test_data(num=1000, generate=false, generate_blob=false)
+      file_name = generate_blob ? "#{num}-blob_data.txt" : "#{num}-data.txt"
+      file = File.join(File.dirname(__FILE__), '..', "testdata", file_name)
+      data = nil
+      if File.exists?(file) and not generate
+        data = open(file, 'r') {|f| Marshal.load(f)}
+      else
+        data = generate_fake_data(num, generate_blob)
+        f = File.new(file, 'w')
+        f.write Marshal.dump(data)
+        f.close
+      end
+      data
+    end
+
+    def get_image_data(objs)
+      blobs = {}
+      objs.keys.each do |key|
+        img_file_name = objs["#{key}"]["filename"]
+        blobs["img_file-rhoblob-#{key}"] =
+          File.new(File.join(File.dirname(__FILE__), "..", "testdata", "images", "#{img_file_name}"), 'rb')
+      end
+      blobs
+    end
+
+    BenchUser = Struct.new(:user_name, :password)
+
+    def get_bench_users(num=1)
+      users = []
+      num.times do |i|
+        user_name = Faker::Internet.user_name
+        password  = Faker::Lorem.words[0] # for more real passwords use 'forgery' gem
+        users << BenchUser.new(user_name, password)
+      end
+      users
+    end
+
+    private
+
+    PREFIX = ["Account", "Administrative", "Advertising", "Assistant", "Banking", "Business Systems", 
+      "Computer", "Distribution", "IT", "Electronics", "Environmental", "Financial", "General", "Head", 
+      "Laboratory", "Maintenance", "Medical", "Production", "Quality Assurance", "Software", "Technical", 
+      "Chief", "Senior"] unless defined? PREFIX
+    SUFFIX = ["Clerk", "Analyst", "Manager", "Supervisor", "Plant Manager", "Mechanic", "Technician", "Engineer", 
+      "Director", "Superintendent", "Specialist", "Technologist", "Estimator", "Scientist", "Foreman", "Nurse", 
+      "Worker", "Helper", "Intern", "Sales", "Mechanic", "Planner", "Recruiter", "Officer", "Superintendent",
+      "Vice President", "Buyer", "Production Supervisor", "Chef", "Accountant", "Executive"] unless defined? SUFFIX
+
+    IMAGE_FILES = %w{
+      icon.ico                loading-LandscapeLeft.png   loading-PortraitUpsideDown.png
+      icon.png                loading-LandscapeRight.png  loading.png
+      loading-Landscape.png   loading-Portrait.png        loading@2x.png }
+
+    EXCLUDE_LIST = %w{ id  mock_id  img_file-rhoblob  img_file_size  filename }
+
+    def title
+      prefix = PREFIX[rand(PREFIX.length)]
+      suffix = SUFFIX[rand(SUFFIX.length)]
+ 
+      "#{prefix} #{suffix}"
+    end
+
+    def generate_fake_data(num, generate_blob)
+      res = {}
+      num.times do |n|
+        mock_id = UUIDTools::UUID.random_create.to_s.gsub(/\-/,'')
+        res[mock_id] = {
+          "mock_id" => mock_id,
+          "FirstName" => Faker::Name.first_name,
+          "LastName" => Faker::Name.last_name,
+          "Email" =>  Faker::Internet.free_email,
+          "Company" => Faker::Company.name,
+          "JobTitle" => title,
+          "Phone1" => Faker::PhoneNumber.phone_number
+        }
+        if generate_blob
+          img_file_name = IMAGE_FILES[rand(IMAGE_FILES.size)]
+          res[mock_id]["img_file-rhoblob"] = img_file_name
+          res[mock_id]["img_file_size"] = 
+            File.size(File.join(File.dirname(__FILE__), "..", "testdata", "images", "#{img_file_name}")).to_s
+          res[mock_id]["filename"] = img_file_name
+
+          # Additional fields: from 0 to 50 will be added to existing 10 ones (total upto 60)
+          words = Faker::Lorem.words(rand(50))
+          words.each do |word|
+            res[mock_id]["#{word}"] = word unless EXCLUDE_LIST.include?(word)
+          end
+        end
+      end
+      res
+    end
+  end
+end

data/bench/lib/bench/timer.rb

@@ -0,0 +1,10 @@
+module Bench
+  module Timer
+    def time
+      start = Time.now
+      yield
+      end_time = Time.now   
+      end_time.to_f - start.to_f
+    end
+  end
+end

data/bench/lib/bench/utils.rb

@@ -0,0 +1,49 @@
+module Bench
+  module Utils
+    include Logging
+    
+    def compare(name1,s1,name2,s2)
+      r1 = diff([],name1,s1,name2,s2)
+      r2 = diff([],name2,s2,name1,s1)
+      r1.size > r2.size ? r1 : r2
+    end
+    
+    def diff(res,lname,lvalue,rname,rvalue,path=[])
+
+      return res if lvalue == rvalue
+      
+      if lvalue.is_a?(Array) and rvalue
+        lvalue.each_index do |index| 
+          p = Array.new(path)
+          p << index
+          diff(res,lname,lvalue[index],rname,rvalue.at(index),p)
+        end                
+      elsif lvalue.is_a?(Hash) and rvalue
+        lvalue.each do |key,value| 
+          p = Array.new(path)
+          p << key
+          diff(res,lname,value,rname,rvalue[key],p)
+        end
+      else            
+        res << {:path=>path,lname=>lvalue,rname=>rvalue}
+      end
+      
+      res 
+    end
+    
+    def compare_and_log(expected,actual,caller)
+      if expected != actual
+        bench_log "#{log_prefix} Verify error at: " + caller
+        bench_log "#{log_prefix} Message diff: "
+        compare(:expected,expected,:actual,actual).each do |diff|
+          bench_log "#{log_prefix} Path: #{diff[:path].join('/')}"
+          bench_log "#{log_prefix} Expected: #{diff[:expected].inspect}"
+          bench_log "#{log_prefix} Actual: #{diff[:actual].inspect}"
+        end
+        1
+      else
+        0
+      end
+    end
+  end
+end