vagas-orientdb4r 0.5.2

data/ci/initialize-ci.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+
+PARENT_DIR=$(dirname $(cd "$(dirname "$0")"; pwd))
+CI_DIR="$PARENT_DIR/ci/environment"
+#CI_DIR=/tmp/travis
+
+ODB_VERSION=${1:-"2.0.4"}
+ODB_DIR="${CI_DIR}/orientdb-community-${ODB_VERSION}"
+ODB_LAUNCHER="${ODB_DIR}/bin/server.sh"
+
+
+
+echo "=== Initializing CI environment ==="
+cd "$PARENT_DIR"
+mkdir -p $CI_DIR
+
+echo "--- Downloading OrientDB v${ODB_VERSION} ---"
+wget -q -O "$CI_DIR/orientdb-community-${ODB_VERSION}.tar.gz" "http://www.orientechnologies.com/download.php?email=unknown@unknown.com&file=orientdb-community-${ODB_VERSION}.tar.gz&os=linux"
+
+echo "--- Unpacking ---------------------"
+tar xf $CI_DIR/orientdb-community-${ODB_VERSION}.tar.gz -C $CI_DIR
+
+echo "--- Setting up --------------------"
+chmod +x $ODB_LAUNCHER
+chmod -R +rw "${ODB_DIR}/config/"
+ODB_ADMIN="<users><user resources=\"*\" password=\"root\" name=\"root\"/></users>"
+sed "s:^[ \t]*<users.*$:    $ODB_ADMIN:" -i ${ODB_DIR}/config/orientdb-server-config.xml
+sed "s:^[ \t]*<\/users.*$:    <!-- \/users -->:" -i ${ODB_DIR}/config/orientdb-server-config.xml
+sed "s:^handlers = .*$:handlers = java.util.logging.ConsoleHandler:" -i ${ODB_DIR}/config/orientdb-server-log.properties
+
+echo "--- Starting server ---------------"
+sh -c $ODB_LAUNCHER </dev/null &>/dev/null &
+
+# Wait a bit for OrientDB to finish the initialization phase.
+sleep 5
+printf "=== The CI environment has been initialized ===\n"

data/fstudy/flat_class_perf.rb

@@ -0,0 +1,56 @@
+require 'study_case'
+
+# This class tests performance on a simple flat class.
+class FlatClassPerf < FStudy::Case
+
+  def db; 'perf'; end
+
+  def drop
+    client.drop_class 'User'
+  end
+  def model
+    drop
+    client.create_class 'User' do |c|
+      c.property 'username', :string, :mandatory => true
+      c.property 'name', :string, :mandatory => true
+      c.property 'admin', :boolean
+    end
+  end
+  def del
+    client.command 'DELETE FROM User'
+  end
+  def data
+    1.upto(100000) do |i|
+      Orientdb4r::logger.info "...done: #{i}" if 0 == (i % 1000)
+      first_name = dg.word
+      surname = dg.word
+      begin
+        client.create_document({ '@class' => 'User', \
+                          :username => "#{first_name}.#{surname}", \
+                          :name => "#{first_name.capitalize} #{surname.capitalize}", \
+                          :admin => (0 == rand(2)) })
+      rescue Exception => e
+        Orientdb4r::logger.error e
+      end
+    end
+  end
+
+  def product
+    1.upto(500000) do |i|
+      Orientdb4r::logger.info "...done: #{i}" if 0 == (i % 100000)
+      name = dg.word
+      type = (rand(3) == 0) ? 'a' : 'b'
+      begin
+        client.command "insert into product cluster #{type} (name,type) values ('#{name}','#{type}')"
+#        client.command "insert into product_simple (name,type) values ('#{name}','#{type}')"
+      rescue Exception => e
+        Orientdb4r::logger.error e
+      end
+    end
+  end
+
+end
+
+c = FlatClassPerf.new
+c.run
+puts 'OK'

data/fstudy/study_case.rb

@@ -0,0 +1,87 @@
+require 'orientdb4r'
+
+module FStudy
+
+  ###
+  # This class represents a elaboration infrastructure.
+  class Case
+
+    attr_reader :dg
+
+    def initialize
+      @dg = DataGenerator.new
+    end
+
+    def db
+      'temp' # default DB is 'temp'
+    end
+    def host
+      'localhost'
+    end
+
+    def client
+      Orientdb4r.client :host => host
+    end
+
+    def watch method
+        start = Time.now
+        self.send method.to_sym
+        Orientdb4r::logger.info "method '#{method}' performed in #{Time.now - start} [s]"
+    end
+
+    def run
+      threads = []
+      thread_cnt = 1
+      thc = ARGV.select { |arg| arg if arg =~ /-th=\d+/ }
+      thread_cnt = thc[0][4..-1].to_i unless thc.empty?
+
+      if thread_cnt > 1
+        1.upto(thread_cnt) do
+          threads << Thread.new do
+            run_threaded
+          end
+        end
+      else
+        run_threaded
+      end
+      threads.each { |th| th.join }
+    end
+
+
+    private
+
+    def run_threaded
+      Orientdb4r::logger.info "started thread #{Thread.current}"
+      client.connect :database => db, :user => 'admin', :password => 'admin'
+      ARGV.each do |arg|
+        watch arg[2..-1].to_sym if arg =~ /^--\w/
+      end
+      client.disconnect
+    end
+
+  end
+
+
+  class DataGenerator
+
+    def initialize
+      @words = IO.readlines('/usr/share/dict/words')
+      0.upto(@words.size - 1) do |i|
+        word = @words[i]
+        word.strip!.downcase!
+        idx = word.index("'")
+        word = word[0..(idx - 1)] unless idx.nil?
+        @words[i] = word
+      end
+      @words.uniq!
+      Orientdb4r::logger.info "DataGenerator: #{@words.size} words"
+    end
+
+    # Gets a random word.
+    def word
+      @words[rand(@words.size)]
+    end
+
+  end
+
+end

data/fstudy/technical_feasibility.rb

@@ -0,0 +1,256 @@
+require 'study_case'
+
+# This class represents model and data for Technical Feasibility Study.
+# See here for more info:
+# https://github.com/veny/orientdb4r/wiki/Technical-Feasibility
+class TechnicalFeasibility < FStudy::Case
+
+  def db; 'perf'; end
+
+  # Dropes the document model.
+  def drop
+    classes_definition.reverse.each do |clazz|
+      client.drop_class clazz[:class]
+      puts "droped class: #{clazz[:class]}"
+    end
+  end
+
+  # Creates the document model.
+  def model
+    drop
+    classes_definition.each do |clazz|
+      class_name = clazz.delete :class
+      client.create_class(class_name, clazz)
+      puts "created class: #{class_name}"
+    end
+  end
+
+  # Deletes data.
+  def del
+    classes_definition.each do |clazz|
+      client.command "DELETE FROM #{clazz[:class]}"
+      puts "deleted from class: #{clazz[:class]}"
+    end
+  end
+
+  # Prepares data.
+  def data
+    communities = insert_communities
+    units = insert_org_units
+    users = insert_users(10000, units, communities)
+    insert_contacts(users, 7) # max pro user => ~ coeficient 4.0 pro user
+    contents = insert_contents(users, communities, 1.0) # coeficient pro user
+    insert_activities(users, communities, contents, 100) # coeficient pro user
+  end
+
+  def count
+    puts client.query 'SELECT count(*) FROM User'
+  end
+
+
+  private
+
+    def insert_communities
+      communities = [
+        { :name => 'Pianists' },
+        { :name => 'Violinists' },
+        { :name => 'Dog fanciers' },
+        { :name => 'Cat fanciers' },
+        { :name => 'Soccer fans' },
+        { :name => 'Ski fans' },
+        { :name => 'Basket fans' },
+        { :name => 'Gourmets' },
+        { :name => 'Scifi reader' },
+        { :name => 'Comic reader' }
+      ]
+
+      start = Time.now
+      communities.each do |c|
+        c['@class'] = 'Community'
+        c[:rid] = client.create_document(c)
+      end
+      puts "Created Communities: #{communities.size}, time = #{Time.now - start} [s]"
+      communities
+    end
+
+    def insert_org_units
+      units = [
+          { :name => 'BigCompany', :descendants => [ 'Automotive', 'Research', 'Infrastructure' ] },
+          { :name => 'Automotive', :descendants => [ 'Sales', 'Marketing', 'Design' ] },
+          { :name => 'Sales' },
+          { :name => 'Marketing' },
+          { :name => 'Design' },
+          { :name => 'Research', :descendants => [ 'Scientist', 'Spies' ] },
+          { :name => 'Scientist' },
+          { :name => 'Spies' },
+          { :name => 'Infrastructure', :descendants => [ 'Accounting', 'HumanResources' ] },
+          { :name => 'Accounting' },
+          { :name => 'HumanResources' , :descendants => [ 'Recruitment' ] },
+          { :name => 'Recruitment' }
+      ]
+
+      start = Time.now
+      units.each { |unit| insert_org_unit_helper(unit, units) }
+      puts "Created OrgUnits: #{units.size}, time = #{Time.now - start} [s]"
+      units
+    end
+    def insert_org_unit_helper(unit, all)
+        return if unit.include? :rid
+
+        if unit.include? :descendants
+          # recursion
+          unit[:descendants].each do |desc_name|
+            next_unit = all.select { |u| u if u[:name] == desc_name }[0]
+            insert_org_unit_helper(next_unit, all) unless next_unit.include? :rid
+          end
+        end
+
+        cloned = unit.clone
+        cloned['@class'] = 'OrgUnit'
+        cloned.delete :descendants
+
+        if unit.include? :descendants
+          descendants = []
+          unit[:descendants].each do |name|
+            descendants << all.select { |ou| ou if ou[:name] == name }[0][:rid]
+          end
+          cloned[:descendants] = descendants
+        end
+
+        rid = client.create_document(cloned)
+        unit[:rid] = rid
+    end
+
+    def insert_users(count, units, communities)
+      start = Time.now
+      users = []
+      1.upto(count) do
+        firstname = dg.word
+        surname = dg.word
+        username =  "#{firstname}.#{surname}"
+        # random distribution of Units (1) & Communities (0..3)
+        unit = units[rand(units.size)]
+        comms = []
+        0.upto(rand(4)) { |i| comms << communities[rand(communities.size)][:rid] if i > 0 }
+
+        user = { '@class' => 'User', \
+                 :username => username, \
+                 :firstname => firstname.capitalize, \
+                 :surname => surname.capitalize, \
+                 :unit => unit[:rid], \
+                 :communities => comms }
+        rid = client.create_document(user)
+        user[:rid] = rid
+        users << user
+      end
+      puts "Created Users: #{users.size}, time = #{Time.now - start} [s]"
+      users
+    end
+
+    def insert_contacts(users, max_contacts)
+      start = Time.now
+      count = 0
+      types = [:friend, :family, :coworker, :enemy]
+      0.upto(users.size - 1) do |i|
+        a = users[i]
+        0.upto(rand(max_contacts)) do
+          b = users[rand(users.size)]
+          client.create_document({'@class' => 'Contact', :a => a[:rid], :b => b[:rid], :type => rand(types.size)})
+          count += 1
+        end
+      end
+      puts "Created Contacts: #{count}, time = #{Time.now - start} [s]"
+    end
+
+    def insert_contents(users, communities, user_coef = 1.0)
+      start = Time.now
+      contents = []
+      classes = [['Article', 'body'], ['Gallery', 'description'], ['Term', 'topic']]
+      limit = (users.size * user_coef).to_i
+
+      1.upto(limit) do
+        clazz = classes[rand(classes.size)]
+        content = {'@class' => clazz[0], :title => "#{dg.word} #{dg.word}", clazz[1] => dg.word}
+        # random distribution of Users (1) & Communities (0..3)
+        content[:author] = users[rand(users.size)][:rid]
+        comms = []
+        0.upto(rand(4)) { |i| comms << communities[rand(communities.size)][:rid] if i > 0 }
+        content[:communities] = comms
+
+        rid = client.create_document(content)
+        content[:rid] = rid
+        contents << content
+      end
+      puts "Created ContentTypes: #{contents.size}, time = #{Time.now - start} [s]"
+      contents
+    end
+
+    def insert_activities(users, communities, contents, user_coef)
+      start = Time.now
+      types = [:login, :logout, :likeit, :rated, :saw, :commented]
+      limit = users.size * user_coef
+      1.upto(limit) do |i|
+        puts "... #{i} #{Time.now - start}" if 0 == i % 100000
+        type = rand(types.size)
+        activity = { '@class' => 'Activity', :type => type, :stamp => (Time.now.to_i - rand(3600*23*30)) }
+        # random distribution of Users (1) & the same communities as user
+        user = users[rand(users.size)]
+        activity[:source] = user[:rid]
+        activity[:communities] = user[:communities]
+        # content
+        content = (types[type] == :login or types[type] == :logout) ? nil : contents[rand(contents.size)]
+        activity[content['@class'].downcase] = content[:rid] unless content.nil?
+
+        begin
+          client.create_document(activity)
+        rescue Exception => e
+          Orientdb4r::logger.error "problem storing index=#{i}, user=#{user.inspect}"
+          Orientdb4r::logger.error e
+        end
+      end
+      puts "Created Activities: #{limit}, time = #{Time.now - start} [s]"
+    end
+
+    def classes_definition
+      # TODO rdbms_id
+      [
+        { :class => 'OrgUnit', :properties => [
+            { :property => 'name', :type => :string, :mandatory => true },
+            # TODO domain
+            { :property => 'descendants',  :type => :linkset, :linked_class => 'OrgUnit' }]},
+        { :class => 'Community', :properties => [
+            { :property => 'name', :type => :string, :mandatory => true }]},
+        { :class => 'User', :properties => [
+            { :property => 'username', :type => :string, :mandatory => true },
+            { :property => 'firstname', :type => :string, :mandatory => true },
+            { :property => 'surname', :type => :string, :mandatory => true },
+            # TODO roles
+            { :property => 'unit',  :type => :link, :linked_class => 'OrgUnit', :mandatory => true },
+            { :property => 'communities',  :type => :linkset, :linked_class => 'Community' }]},
+        { :class => 'Contact', :properties => [
+            { :property => 'type', :type => :integer, :mandatory => true },
+            { :property => 'a',  :type => :link, :linked_class => 'User', :mandatory => true },
+            { :property => 'b',  :type => :link, :linked_class => 'User', :mandatory => true }]},
+        { :class => 'Content', :properties => [
+            { :property => 'title', :type => :string, :mandatory => true },
+            { :property => 'author',  :type => :link, :linked_class => 'User', :mandatory => true },
+            { :property => 'accessible_in', :type => :linkset, :linked_class => 'Community' }]},
+        { :class => 'Article', :extends => 'Content', :properties => [
+            { :property => 'body', :type => :string, :mandatory => true }]},
+        { :class => 'Gallery', :extends => 'Content', :properties => [
+            { :property => 'description', :type => :string, :mandatory => true }]},
+        { :class => 'Term', :extends => 'Content', :properties => [
+            { :property => 'topic', :type => :string, :mandatory => true }]},
+        { :class => 'Activity', :properties => [
+            { :property => 'type', :type => :integer, :mandatory => true },
+            { :property => 'stamp', :type => :integer, :mandatory => true },
+            { :property => 'source',  :type => :link, :linked_class => 'User', :mandatory => true },
+            { :property => 'communities', :type => :linkset, :linked_class => 'Community' }]}
+      ]
+    end
+
+end
+
+c = TechnicalFeasibility.new
+c.run
+puts 'OK'