litestack 0.4.1 → 0.4.3

data/bench/bench_cache_raw.rb

@@ -1,17 +1,17 @@
-require 'redis'
-require 'sqlite3'
-require_relative './bench'
+require "redis"
+require "sqlite3"
+require_relative "./bench"
 
-#require 'polyphony'
-require 'async/scheduler'
+# require 'polyphony'
+require "async/scheduler"
 
 Fiber.set_scheduler Async::Scheduler.new
 Fiber.scheduler.run
 
-require_relative '../lib/litestack/litecache'
-#require 'litestack'
+require_relative "../lib/litestack/litecache"
+# require 'litestack'
 
-cache = Litecache.new({path: '../db/cache.db'}) # default settings
+cache = Litecache.new #({path: "../db/cache.db"}) # default settings
 redis = Redis.new # default settings
 
 values = []
@@ -21,13 +21,13 @@ count.times { keys << random_str(10) }
 
 [10, 100, 1000, 10000].each do |size|
   count.times do
-    values << random_str(size) 
+    values << random_str(size)
   end
-  
+
   random_keys = keys.shuffle
-  
+
   GC.compact
-  
+
   puts "Benchmarks for values of size #{size} bytes"
   puts "=========================================================="
   puts "== Writes =="
@@ -35,37 +35,54 @@ count.times { keys << random_str(10) }
     cache.set(keys[i], values[i])
   end
 
-  #bench("file writes", count) do |i|
-  #  f = File.open("../files/#{keys[i]}.data", 'w+')
-  #  f.write(values[i])
-  #  f.close
-  #end
-  
-
   bench("Redis writes", count) do |i|
     redis.set(keys[i], values[i])
   end
 
+  puts "== Multi Writes =="
+  bench("litecache multi-writes", count/5) do |i|
+    idx = i * 5 
+    payload = {} 
+    5.times {|j| payload[keys[idx + j]] = values[idx + j] }
+    cache.set_multi(payload)
+  end 
+
+  bench("Redis multi-writes", count/5) do |i|
+    idx = i * 5 
+    payload = [] 
+    5.times {|j| payload << keys[idx + j]; payload <<  values[idx + j]}
+    redis.mset(*payload)
+  end
+
   puts "== Reads =="
   bench("litecache reads", count) do |i|
     cache.get(random_keys[i])
   end
 
-  #bench("file reads", count) do |i|
-  #  data = File.read("../files/#{keys[i]}.data")
-  #end
-
   bench("Redis reads", count) do |i|
     redis.get(random_keys[i])
   end
+
+  puts "== Multi Reads =="
+  bench("litecache multi-reads", count/5) do |i|
+    idx = i * 5
+    payload = []
+    5.times {|j| payload << random_keys[idx+j]}
+    cache.get_multi(*payload)
+  end
+
+  bench("Redis multi-reads", count/5) do |i|
+    idx = i * 5
+    payload = []
+    5.times {|j| payload << random_keys[idx+j]}
+    redis.mget(*payload)
+  end
+
   puts "=========================================================="
 
   values = []
-  
-  
 end
 
-
 cache.set("somekey", 1)
 redis.set("somekey", 1)
 
@@ -80,5 +97,4 @@ end
 cache.clear
 redis.flushdb
 
-#sleep
-
+# sleep

data/bench/bench_jobs_rails.rb

@@ -1,39 +1,45 @@
-require './bench'
+require "./bench"
 
-count = ARGV[0].to_i rescue 1000
+count = begin
+  ARGV[0].to_i
+rescue
+  1000
+end
 env = ARGV[1] || "t"
-delay = ARGV[2].to_f rescue 0
-
+_delay = begin
+  ARGV[2].to_f
+rescue
+  0
+end
 
-#ActiveJob::Base.logger = Logger.new(IO::NULL)
+# ActiveJob::Base.logger = Logger.new(IO::NULL)
 
-require './rails_job.rb'
+require "./rails_job"
 
 RailsJob.queue_adapter = :sidekiq
 t = Time.now.to_f
-puts "Make sure sidekiq is started with -c ./rails_job.rb"     
-bench("enqueuing sidekiq jobs", count) do 
+puts "Make sure sidekiq is started with -c ./rails_job.rb"
+bench("enqueuing sidekiq jobs", count) do
   RailsJob.perform_later(count, t)
 end
 
 puts "Don't forget to check the sidekiq log for processing time conclusion"
 
-
 # Litejob bench
 ###############
 
 if env == "a" # threaded
-  require 'async/scheduler'
+  require "async/scheduler"
   Fiber.set_scheduler Async::Scheduler.new
   ActiveSupport::IsolatedExecutionState.isolation_level = :fiber
 end
 
-require_relative '../lib/active_job/queue_adapters/litejob_adapter'
+require_relative "../lib/active_job/queue_adapters/litejob_adapter"
 puts Litescheduler.backend
 
 RailsJob.queue_adapter = :litejob
 t = Time.now.to_f
-bench("enqueuing litejobs", count) do 
+bench("enqueuing litejobs", count) do
   RailsJob.perform_later(count, t)
 end
 

data/bench/bench_jobs_raw.rb

@@ -1,15 +1,23 @@
-require './bench'
+require "./bench"
 
-count = ARGV[0].to_i rescue 1000
+count = begin
+  ARGV[0].to_i
+rescue
+  1000
+end
 env = ARGV[1] || "t"
-delay = ARGV[2].to_f rescue 0
+delay = begin
+  ARGV[2].to_f
+rescue
+  0
+end
 
 # Sidekiq bench
 ###############
-require './skjob.rb'
+require "./skjob"
 
 t = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-puts "make sure sidekiq is started with skjob.rb as the job"     
+puts "make sure sidekiq is started with skjob.rb as the job"
 bench("enqueuing sidekiq jobs", count) do |i|
   SidekiqJob.perform_async(count, t, delay)
 end
@@ -20,15 +28,15 @@ puts "Don't forget to check the sidekiq log for processing time conclusion"
 ###############
 
 if env == "t" # threaded
-  # do nothing 
+  # do nothing
 elsif env == "a" # async
-  require 'async/scheduler'
+  require "async/scheduler"
   Fiber.set_scheduler Async::Scheduler.new
 end
 
-require './uljob.rb'
+require "./uljob"
 
-STDERR.puts "litejob started in #{Litescheduler.backend} environmnet"
+warn "litejob started in #{Litescheduler.backend} environment"
 
 t = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 bench("enqueuing litejobs", count) do |i|
@@ -40,4 +48,3 @@ puts "Please wait for the benchmark to finish .."
 Fiber.scheduler.run if env == "a"
 
 sleep
-

data/bench/bench_queue.rb

@@ -1,16 +1,14 @@
-require './bench'
-require_relative '../lib/litestack'
+require "./bench"
+require_relative "../lib/litestack"
 
 count = 1000
 
-q = Litequeue.new({path: '../db/queue.db' })
+q = Litequeue.new({path: "../db/queue.db"})
 
 bench("Litequeue enqueue", count) do |i|
   q.push i.to_s
 end
 
 bench("Litequeue dequeue", count) do |i|
-  q.pop  
+  q.pop
 end
-
-

data/bench/rails_job.rb

@@ -1,18 +1,16 @@
-require 'active_job'
+require "active_job"
 
 class RailsJob < ActiveJob::Base
-  
   queue_as :default
 
   @@count = 0
-  
+
   def perform(count, time)
-    #sleep 1
-    @@count += 1 
-    if @@count == count  
+    # sleep 1
+    @@count += 1
+    if @@count == count
       puts "[litejob] Finished in #{Time.now.to_f - time} seconds (#{count / (Time.now.to_f - time)} jps)"
       @@count = 0
     end
   end
-
 end

data/bench/skjob.rb

@@ -1,14 +1,14 @@
-require 'sidekiq'
+require "sidekiq"
 
 class SidekiqJob
   include Sidekiq::Job
   @@count = 0
   def perform(count, time, sleep_interval = nil)
-    sleep sleep_interval if sleep_interval  
+    sleep sleep_interval if sleep_interval
     @@count += 1
-    if @@count == count  
+    if @@count == count
       now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      STDERR.puts "Sidekiq finished in #{now - time} seconds (#{count / (now - time)} jps)"
+      warn "Sidekiq finished in #{now - time} seconds (#{count / (now - time)} jps)"
       @@count = 0
     end
   end

data/bench/uljob.rb

@@ -1,16 +1,16 @@
-require './bench'
-require '../lib/litestack/litejob'
+require "./bench"
+require "../lib/litestack/litejob"
 
 class MyJob
   include Litejob
   @@count = 0
-  #self.queue = :default
+  # self.queue = :default
   def perform(count, time, sleep_interval = nil)
-    sleep sleep_interval if sleep_interval  
+    sleep sleep_interval if sleep_interval
     @@count += 1
-    if @@count == count  
+    if @@count == count
       now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      STDERR.puts "Litejob finished in #{now - time} seconds (#{count / (now - time)} jps)"
+      warn "Litejob finished in #{now - time} seconds (#{count / (now - time)} jps)"
     end
   end
 end

data/bin/liteboard

@@ -15,6 +15,7 @@ options = {
   Port: 9292,
   Host: 'localhost',
   environment: 'production',
+  pid: 'tmp/pids/liteboard.pid',
   quiet: false
 }
 
@@ -25,7 +26,7 @@ OptionParser.new do |parser|
   parser.on("-s", "--server SERVER", "use SERVER (e.g. puma/falcon/iodine)") { |v| options[:port] = v }
   parser.on("-H", "--host HOST", "listen on HOST (default: #{options[:Host]})") { |v| options[:Host] = v }
   parser.on("-p", "--port PORT", "use PORT (default: #{options[:Port]})") { |v| options[:Port] = v.to_i rescue options[:Port] }
-  parser.on("-D", "--deamonize", "run in the background") { |v| options[:deamonize] = true }  
+  parser.on("-D", "--daemonize", "run in the background") { |v| options[:daemonize] = true }  
   parser.on("-E", "--env ENVIRONMENT", "which environment to use (default: #{options[:environment]})") { |v| options[:environment] = v }  
   parser.on("-q", "--quiet", "turn off logging") { |v| options[:quiet] = true }  
   parser.on("-h", "--help", "print this message") do

data/lib/action_cable/subscription_adapter/litecable.rb

@@ -1,26 +1,23 @@
 # frozen_stringe_literal: true
 
-require_relative '../../litestack/litecable'
+require_relative "../../litestack/litecable"
 
 module ActionCable
   module SubscriptionAdapter
-    class Litecable < ::Litecable# :nodoc:
-
+    class Litecable < ::Litecable # :nodoc:
       attr_reader :logger, :server
-      
+
       prepend ChannelPrefix
 
-      def initialize(server, logger=nil)
+      def initialize(server, logger = nil)
         @server = server
         @logger = server.logger
         super({config_path: "./config/litecable.yml"})
       end
-            
+
       def shutdown
         close
       end
-    
     end
   end
 end
-

data/lib/active_job/queue_adapters/litejob_adapter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../litestack/litejob.rb'
+require_relative "../../litestack/litejob"
 require "active_support/core_ext/enumerable"
 require "active_support/core_ext/array/access"
 require "active_job"
@@ -12,13 +12,12 @@ module ActiveJob
     #
     #   Rails.application.config.active_job.queue_adapter = :litejob
     class LitejobAdapter
-          
-      def initialize(options={})
+      def initialize(options = {})
         # we currently don't honour individual options per job class
         # possible in the future?
         # Job.options = DEFAULT_OPTIONS.merge(options)
       end
-    
+
       def enqueue(job) # :nodoc:
         Job.queue = job.queue_name
         Job.perform_async(job.serialize)
@@ -30,14 +29,13 @@ module ActiveJob
       end
 
       class Job # :nodoc:
-        
         DEFAULT_OPTIONS = {
           config_path: "./config/litejob.yml",
-          logger: nil, # Rails performs its logging already
-        }      
+          logger: nil # Rails performs its logging already
+        }
 
         include ::Litejob
-  
+
         def perform(job_data)
           Base.execute job_data
         end

data/lib/active_record/connection_adapters/litedb_adapter.rb

@@ -1,102 +1,90 @@
-require_relative '../../litestack/litedb'
-require 'active_record'
-require 'active_record/connection_adapters/sqlite3_adapter'
-require 'active_record/tasks/sqlite_database_tasks'
+require_relative "../../litestack/litedb"
+require "active_record"
+require "active_record/connection_adapters/sqlite3_adapter"
+require "active_record/tasks/sqlite_database_tasks"
 
 module ActiveRecord
+  module ConnectionHandling # :nodoc:
+    def litedb_connection(config)
+      config = config.symbolize_keys
 
-	module ConnectionHandling # :nodoc:
-
-		def litedb_connection(config)
-
-			config = config.symbolize_keys
-
-			# Require database.
-			unless config[:database]
-				raise ArgumentError, "No database file specified. Missing argument: database"
-			end
-
-			# Allow database path relative to Rails.root, but only if the database
-			# path is not the special path that tells sqlite to build a database only
-			# in memory.
-			if ":memory:" != config[:database] && !config[:database].to_s.start_with?("file:")
-				config[:database] = File.expand_path(config[:database], Rails.root) if defined?(Rails.root)
-				dirname = File.dirname(config[:database])
-				Dir.mkdir(dirname) unless File.directory?(dirname)
-			end
-
-			db = ::Litedb.new(
-				config[:database].to_s,
-				config.merge(results_as_hash: true)
-			)
+      # Require database.
+      unless config[:database]
+        raise ArgumentError, "No database file specified. Missing argument: database"
+      end
 
-			ConnectionAdapters::LitedbAdapter.new(db, logger, nil, config)
-			
-		rescue Errno::ENOENT => error
-			if error.message.include?("No such file or directory")
-				raise ActiveRecord::NoDatabaseError
-			else
-				raise
-			end
-		end
-	end
+      # Allow database path relative to Rails.root, but only if the database
+      # path is not the special path that tells sqlite to build a database only
+      # in memory.
+      if config[:database] != ":memory:" && !config[:database].to_s.start_with?("file:")
+        config[:database] = File.expand_path(config[:database], Rails.root) if defined?(Rails.root)
+        dirname = File.dirname(config[:database])
+        Dir.mkdir(dirname) unless File.directory?(dirname)
+      end
 
-	module ConnectionAdapters # :nodoc:
+      db = ::Litedb.new(
+        config[:database].to_s,
+        config.merge(results_as_hash: true)
+      )
+
+      ConnectionAdapters::LitedbAdapter.new(db, logger, nil, config)
+    rescue Errno::ENOENT => error
+      if error.message.include?("No such file or directory")
+        raise ActiveRecord::NoDatabaseError
+      else
+        raise
+      end
+    end
+  end
 
-		class LitedbAdapter < SQLite3Adapter
+  module ConnectionAdapters # :nodoc:
+    class LitedbAdapter < SQLite3Adapter
+      ADAPTER_NAME = "litedb"
 
-		  ADAPTER_NAME = "litedb"
-  
-      class << self
-        
-        def dbconsole(config, options = {})
-          args = []
+      def self.dbconsole(config, options = {})
+        args = []
 
-          args << "-#{options[:mode]}" if options[:mode]
-          args << "-header" if options[:header]
-          args << File.expand_path(config.database, Rails.respond_to?(:root) ? Rails.root : nil)
+        args << "-#{options[:mode]}" if options[:mode]
+        args << "-header" if options[:header]
+        args << File.expand_path(config.database, Rails.respond_to?(:root) ? Rails.root : nil)
 
-          find_cmd_and_exec("sqlite3", *args)
-        end
-        		
+        self.find_cmd_and_exec("sqlite3", *args)
       end
+      
+      NATIVE_DATABASE_TYPES = {
+        primary_key: "integer PRIMARY KEY NOT NULL",
+        string: {name: "text"},
+        text: {name: "text"},
+        integer: {name: "integer"},
+        float: {name: "real"},
+        decimal: {name: "real"},
+        datetime: {name: "text"},
+        time: {name: "integer"},
+        date: {name: "text"},
+        binary: {name: "blob"},
+        boolean: {name: "integer"},
+        json: {name: "text"},
+        unixtime: {name: "integer"}
+      }
+
+      private
+
+      def connect
+        @raw_connection = ::Litedb.new(
+          @config[:database].to_s,
+          @config.merge(results_as_hash: true)
+        )
+        configure_connection
+      end
+    end
+  end
 
-		  NATIVE_DATABASE_TYPES = {
-			  primary_key:  "integer PRIMARY KEY NOT NULL",
-			  string:       { name: "text" },
-			  text:         { name: "text" },
-			  integer:      { name: "integer" },
-			  float:        { name: "real" },
-			  decimal:      { name: "real" },
-			  datetime:     { name: "text" },
-			  time:         { name: "integer" },
-			  date:         { name: "text" },
-			  binary:       { name: "blob" },
-			  boolean:      { name: "integer" },
-			  json:         { name: "text" },
-                          unixtime:     { name: "integer" }
-		  }
-		  
-		  private
-		  
-	      def connect
-            @raw_connection = ::Litedb.new(
-              @config[:database].to_s,
-              @config.merge(results_as_hash: true)
-            )
-            configure_connection
-        end
-		end
-
-	end
-	
   module Tasks # :nodoc:
     class LitedbDatabaseTasks < SQLiteDatabaseTasks # :nodoc:
     end
-    
+
     module DatabaseTasks
       register_task(/litedb/, "ActiveRecord::Tasks::LitedbDatabaseTasks")
-
     end
-	end
+  end
 end