roma 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4c0c8e4fac7121c2eded725b92fdd79bbc38ee9a
-  data.tar.gz: e1e9185743aa59abccd0ca9d16170806a91868e1
+  metadata.gz: a17bad1bbf7dabab9d9833e7458902691dae3117
+  data.tar.gz: e97e8fb05d535d000d276dcea350317629ef9a00
 SHA512:
-  metadata.gz: f9e18113c7d99b224a9fd045fb52892f130d75c6e989b20e2e28cf168a13c7f3f1c8352fa72c7eec23c00c0490b28277e8acbc0d0a9166f10cef66d382a0c6cf
-  data.tar.gz: d6a9693f346d9e536489ea591734f73b3879933b4f0ca1bb86a8d4904aa60afc7fb709df0fa3d23cfc01e2932ecdd69919a2cec3c7a21cd93f091b90d9782ae0
+  metadata.gz: f5dc132fd3475bcd2a4edceaa579bbf9b18319a84dda1ce7c443b1e40ab1cdb538e7bb791cb693d497b98867990ad31c294ee4f7969f1b20616b31a6bcb05de3
+  data.tar.gz: 3d2854df8f09147235a49a5891037fa65e5be84a59c73bacbfb3739decd8f0a3c728bdac2d44fb69e7aa2026c53ffef1abbe898695e62e5a098d7fcd9e76df59

data/CHANGELOG

@@ -1,3 +1,24 @@
+*1.1.0 (Aug 19 2015)*
+
+* Change gemspec [Hiroaki Iwase] db2bb42
+* Modify unit-test [Hiroaki Iwase] 7479034
+* Adjust secondary node to redundancy over3 [Hiroaki Iwase] a6fafd8
+* Add new func to check tokyo cabinet additional flag [Hiroaki Iwase] e17b3af
+* Make new tool(roma-adm) [Hiroaki Iwase] 8cf2a03
+* Add new func to check config.rb version when booting [Hiroaki Iwase] 1befb8f
+* Add new func to check command miss spell by jaro-winkler [Hiroaki Iwase] 607c96e
+* Enable to check failover status on stats[Hiroaki Iwase] d5a6a9f
+* Enable to check log level on stats [Hiroaki Iwase] 14b1455
+* Modify duplicate problem(plugin_storage.rb) of mkconfig script [Hiroaki Iwase] c057191
+* Adjust groonga [Hiroaki Iwase] 0ee097c
+* Add new command(shutdown_self) [Hiroaki Iwase] 8bb0aa5
+* add new testcase about cpdb as Groonga msg [ooeyoshinori] 6744580
+* Fix random routing logic for join [Hiroki Matsue] ea29af3
+* Support new stats interface of client and refactor codes. [Hiroki Matsue] fd65292
+* Add tests for routing logic and refactor tests [Hiroki Matsue] 1d52cbe
+* Add Dynamic Log Shift size and age Test  Script [Paras Patel] 081ebd2
+* Remove unnecessary path in ssroute booting file [Hiroaki Iwase] 4f678cd
+
 *1.1.0 (Mar 30 2015)*
 
 * I improved connection performance during booting [Takahiro Tokunaga] ee411f0

data/Gemfile.lock

@@ -0,0 +1,47 @@
+PATH
+  remote: .
+  specs:
+    roma (1.2.0)
+      eventmachine (~> 1.0.0)
+      jaro_winkler (~> 1.3.5)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    archive-zip (0.7.0)
+      io-like (~> 0.3.0)
+    eventmachine (1.0.3)
+    ffi (1.9.6)
+    gdbm (1.2)
+    gqtp (1.0.6)
+    groonga-client (0.1.0)
+      gqtp (>= 1.0.4)
+      groonga-command (>= 1.0.8)
+    groonga-command (1.0.9)
+      json
+    io-like (0.3.0)
+    jaro_winkler (1.3.5)
+    json (1.8.1)
+    pkg-config (1.1.6)
+    power_assert (0.2.2)
+    rake (10.2.2)
+    rroonga (4.0.8)
+      archive-zip
+      groonga-client (>= 0.0.3)
+      json
+      pkg-config
+    sqlite3 (1.3.9)
+    test-unit (3.1.2)
+      power_assert
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  ffi
+  gdbm
+  rake
+  roma!
+  rroonga
+  sqlite3
+  test-unit

data/bin/check_tc_flag

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+require 'pathname'
+require 'optparse'
+
+base_path = Pathname(__FILE__).dirname.parent.expand_path
+$LOAD_PATH.unshift("#{base_path}/lib")
+
+require 'roma/tools/check_tc_flag'
+
+begin
+  # argument check
+  if ARGV.size <= 0 || ARGV.size > 4
+    puts "Argument Error: check_tc_flag --storage [TC storage path] --library [TC library path]"
+    exit
+  end
+
+  # opt parse
+  options = {}
+  opts = OptionParser.new
+  opts.banner="usage:#{File.basename($0)} --path [directory path]"
+  opts.on("-h", "--help", "Show this message") { puts opts; exit }
+
+  opts.on("--storage <dir_path>", "Specify the TC Storage directory", "Ex.)/roma/ds/localhost_10001/roma") {|v| options[:storage] = v}
+  opts.on("--library <dir_path>", "Specify the TC library directory", "Ex.)/roma/libexec") {|v| options[:library] = v}
+  opts.parse!(ARGV)
+
+  # add default path(current directory)
+  options[:storage] = '.' unless options.has_key?(:storage)
+  options[:library] = '.' unless options.has_key?(:library)
+
+  tc = Roma::CheckTc.new(options[:storage], options[:library])
+  res = tc.check_flag
+  res.each{|f, flag|
+    flag = "(no flag)" if flag.empty?
+    puts "#{f} : #{flag}"
+  }
+rescue => e
+  puts e.message
+end

data/bin/roma-adm

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+require 'pathname'
+require 'optparse'
+
+base_path = Pathname(__FILE__).dirname.parent.expand_path
+$LOAD_PATH.unshift("#{base_path}/lib")
+
+require 'roma/tools/roma-adm'
+
+begin
+  # opt parse
+  opts = OptionParser.new
+  opts.banner="usage:#{File.basename($0)} [command] [port No.]"
+  opts.on("-h", "--help", "Show this message") {
+    puts opts; exit
+  }
+  opts.parse!(ARGV)
+  
+  # argument check
+  if ARGV.size < 1 || ARGV.size > 2
+    puts "Argument Error: roma-adm [adm-command] [port No.]"
+    exit
+  elsif ARGV.size == 2 && ARGV[1] !~ /^\d+$/
+    puts "Argument Error: roma-adm [adm-command] [port No.]"
+    puts "[port No.] should be Interger"
+    exit
+  end
+
+  cmd = ARGV[0]
+  if ARGV[1]
+    port = ARGV[1]
+  else
+    port = "12000" # defaul port
+  end
+
+  adm = Roma::Adm.new(cmd, port)
+  adm.check_type
+  res = adm.send_command
+  puts "\r\n"
+  puts res
+rescue => e
+  puts e.message
+end

data/bin/ssroute

@@ -4,7 +4,4 @@ require 'pathname'
 base_path = Pathname(__FILE__).dirname.parent.expand_path
 $LOAD_PATH.unshift("#{base_path}/lib")
 
-client_base_path = Pathname(__FILE__).dirname.parent.parent.expand_path
-$LOAD_PATH.unshift("#{client_base_path}/roma-ruby-client/lib")
-
 require 'roma/tools/ssroute'

data/lib/roma/async_process.rb

@@ -1,15 +1,14 @@
 require 'thread'
 require 'digest/sha1'
-require "timeout"
+require 'timeout'
 
 module Roma
-
   class AsyncMessage
     attr_accessor :event
     attr_accessor :args
     attr_accessor :callback
 
-    def initialize(ev,ag=nil,&cb)
+    def initialize(ev, ag = nil, &cb)
       @event = ev
       @args = ag
       @callback = cb
@@ -32,7 +31,6 @@ module Roma
   end
 
   module AsyncProcess
-
     @@async_queue = Queue.new
     @@async_queue_latency = Queue.new
 
@@ -45,17 +43,17 @@ module Roma
     end
 
     def start_async_process
-      @async_thread = Thread.new{
+      @async_thread = Thread.new do
         async_process_loop
-      }
+      end
       @async_thread[:name] = __method__
 
-      @async_thread_latency = Thread.new{
+      @async_thread_latency = Thread.new do
         async_process_loop_for_latency
-      }
+      end
       @async_thread_latency[:name] = __method__
-    rescue =>e
-      @log.error("#{e}\n#{$@}")
+    rescue => e
+      @log.error("#{e}\n#{$ERROR_POSITION}")
     end
 
     private
@@ -77,66 +75,66 @@ module Roma
     end
 
     def async_process_loop
-      loop {
+      loop do
         while msg = @@async_queue.pop
-          if send("asyncev_#{msg.event}",msg.args)
-            msg.callback.call(msg,true) if msg.callback
+          if send("asyncev_#{msg.event}", msg.args)
+            msg.callback.call(msg, true) if msg.callback
           else
             if msg.retry?
-              t = Thread.new{
+              t = Thread.new do
                 msg.wait
                 msg.incr_count
                 @@async_queue.push(msg)
-              }
+              end
               t[:name] = __method__
             else
               @log.error("async process retry out:#{msg.inspect}")
-              msg.callback.call(msg,false) if msg.callback
+              msg.callback.call(msg, false) if msg.callback
             end
           end
         end
-      }
-    rescue =>e
-      @log.error("#{e}\n#{$@}")
+      end
+    rescue => e
+      @log.error("#{e}\n#{$ERROR_POSITION}")
       retry
     end
 
     def async_process_loop_for_latency
-      loop {
+      loop do
         while msg = @@async_queue_latency.pop
-          if send("asyncev_#{msg.event}",msg.args)
-            msg.callback.call(msg,true) if msg.callback
+          if send("asyncev_#{msg.event}", msg.args)
+            msg.callback.call(msg, true) if msg.callback
           else
             if msg.retry?
-              t = Thread.new{
+              t = Thread.new do
                 msg.wait
                 msg.incr_count
                 @@async_queue_latency.push(msg)
-              }
+              end
               t[:name] = __method__
             else
               @log.error("async process retry out:#{msg.inspect}")
-              msg.callback.call(msg,false) if msg.callback
+              msg.callback.call(msg, false) if msg.callback
             end
           end
         end
-      }
-    rescue =>e
-      @log.error("#{e}\n#{$@}")
+      end
+    rescue => e
+      @log.error("#{e}\n#{$ERROR_POSITION}")
       retry
     end
 
     def asyncev_broadcast_cmd(args)
       @log.debug("#{__method__} #{args.inspect}")
       cmd, nids, tout = args
-      t = Thread::new{
+      t = Thread.new do
         async_broadcast_cmd("#{cmd}\r\n", nids, tout)
-      }
+      end
       t[:name] = __method__
       true
     end
 
-    def asyncev_start_join_process(args)
+    def asyncev_start_join_process(_args)
       @log.debug(__method__)
       if @stats.run_join
         @log.error("#{__method__}:join process running")
@@ -151,11 +149,11 @@ module Roma
         return true
       end
       @stats.run_join = true
-      t = Thread::new do
+      t = Thread.new do
         begin
           join_process
-        rescue =>e
-          @log.error("#{__method__}:#{e.inspect} #{$@}")
+        rescue => e
+          @log.error("#{__method__}:#{e.inspect} #{$ERROR_POSITION}")
         ensure
           @stats.run_join = false
           @stats.join_ap = nil
@@ -165,7 +163,7 @@ module Roma
       true
     end
 
-    def asyncev_start_balance_process(args)
+    def asyncev_start_balance_process(_args)
       @log.debug(__method__)
       if @stats.run_join
         @log.error("#{__method__}:join process running")
@@ -180,11 +178,11 @@ module Roma
         return true
       end
       @stats.run_balance = true
-      t = Thread::new do
+      t = Thread.new do
         begin
           balance_process
-        rescue =>e
-          @log.error("#{__method__}:#{e.inspect} #{$@}")
+        rescue => e
+          @log.error("#{__method__}:#{e.inspect} #{$ERROR_POSITION}")
         ensure
           @stats.run_balance = false
         end
@@ -194,14 +192,14 @@ module Roma
     end
 
     def asyncev_redundant(args)
-      nid,hname,k,d,clk,expt,v = args
+      nid, hname, k, d, clk, expt, v = args
       @log.debug("#{__method__} #{args.inspect}")
       unless @rttable.nodes.include?(nid)
         @log.warn("async redundant failed:#{nid} does not found in routing table.#{k}\e#{hname} #{d} #{clk} #{expt} #{v.length}")
         return true # no retry
       end
-      res = async_send_cmd(nid,"rset #{k}\e#{hname} #{d} #{clk} #{expt} #{v.length}\r\n#{v}\r\n",10)
-      if res == nil || res.start_with?("ERROR")
+      res = async_send_cmd(nid, "rset #{k}\e#{hname} #{d} #{clk} #{expt} #{v.length}\r\n#{v}\r\n", 10)
+      if res.nil? || res.start_with?('ERROR')
         @log.warn("async redundant failed:#{k}\e#{hname} #{d} #{clk} #{expt} #{v.length} -> #{nid}")
         return false # retry
       end
@@ -209,14 +207,14 @@ module Roma
     end
 
     def asyncev_zredundant(args)
-      nid,hname,k,d,clk,expt,zv = args
+      nid, hname, k, d, clk, expt, zv = args
       @log.debug("#{__method__} #{args.inspect}")
       unless @rttable.nodes.include?(nid)
         @log.warn("async zredundant failed:#{nid} does not found in routing table.#{k}\e#{hname} #{d} #{clk} #{expt} #{zv.length}")
         return true # no retry
       end
-      res = async_send_cmd(nid,"rzset #{k}\e#{hname} #{d} #{clk} #{expt} #{zv.length}\r\n#{zv}\r\n",10)
-      if res == nil || res.start_with?("ERROR")
+      res = async_send_cmd(nid, "rzset #{k}\e#{hname} #{d} #{clk} #{expt} #{zv.length}\r\n#{zv}\r\n", 10)
+      if res.nil? || res.start_with?('ERROR')
         @log.warn("async zredundant failed:#{k}\e#{hname} #{d} #{clk} #{expt} #{v.length} -> #{nid}")
         return false # retry
       end
@@ -224,13 +222,13 @@ module Roma
     end
 
     def asyncev_rdelete(args)
-      nid,hname,k,clk = args
+      nid, hname, k, clk = args
       @log.debug("#{__method__} #{args.inspect}")
       unless @rttable.nodes.include?(nid)
         @log.warn("async rdelete failed:#{nid} does not found in routing table.#{k}\e#{hname} #{clk}")
         return true # no retry
       end
-      res = async_send_cmd(nid,"rdelete #{k}\e#{hname} #{clk}\r\n",10)
+      res = async_send_cmd(nid, "rdelete #{k}\e#{hname} #{clk}\r\n", 10)
       unless res
         @log.warn("async redundant failed:#{k}\e#{hname} #{clk} -> #{nid}")
         return false # retry
@@ -245,11 +243,11 @@ module Roma
         @log.warn("#{__method__}:already be iterated storage process.")
       else
         @stats.run_iterate_storage = true
-        t = Thread::new do
+        t = Thread.new do
           begin
             sync_a_vnode(vn.to_i, nid, p == 'true')
-          rescue =>e
-            @log.error("#{__method__}:#{e.inspect} #{$@}")
+          rescue => e
+            @log.error("#{__method__}:#{e.inspect} #{$ERROR_POSITION}")
           ensure
             @stats.run_iterate_storage = false
           end
@@ -273,11 +271,11 @@ module Roma
         return true
       end
       @stats.run_recover = true
-      t = Thread::new do
+      t = Thread.new do
         begin
           acquired_recover_process
         rescue => e
-          @log.error("#{__method__}:#{e.inspect} #{$@}")
+          @log.error("#{__method__}:#{e.inspect} #{$ERROR_POSITION}")
         ensure
           @stats.run_recover = false
         end
@@ -287,11 +285,11 @@ module Roma
 
     def asyncev_start_auto_recover_process(args)
       @log.debug("#{__method__} #{args.inspect}")
-      ###run_join don't have possibility to be true in this case.
-      #if @stats.run_join
+      # ##run_join don't have possibility to be true in this case.
+      # if @stats.run_join
       #  @log.error("#{__method__}:join process running")
       #  return true
-      #end
+      # end
       if @stats.run_recover
         @log.error("#{__method__}:recover process running.")
         return false
@@ -301,35 +299,35 @@ module Roma
         return true
       end
 
-      @rttable.auto_recover_status = "preparing"
-      t = Thread::new do
+      @rttable.auto_recover_status = 'preparing'
+      t = Thread.new do
         begin
-          timeout(@rttable.auto_recover_time){
-            loop{
+          timeout(@rttable.auto_recover_time)do
+            loop do
               sleep 1
-              break if @rttable.auto_recover_status != "preparing"
-              #break if @stats.run_join #run_join don't have possibility to be true in this case.
+              break if @rttable.auto_recover_status != 'preparing'
+              # break if @stats.run_join #run_join don't have possibility to be true in this case.
               break if @stats.run_recover
               break if @stats.run_balance
-            }
-          }
-          @log.debug("inactivated AUTO_RECOVER")
+            end
+          end
+          @log.debug('inactivated AUTO_RECOVER')
         rescue
           case @rttable.lost_action
             when :auto_assign, :shutdown
               @stats.run_recover = true
-              @rttable.auto_recover_status = "executing"
-                begin
-                  @log.debug("auto recover start")
-                  acquired_recover_process
-                rescue => e
-                  @log.error("#{__method__}:#{e.inspect} #{$@}")
-                ensure
-                  @stats.run_recover = false
-                  @rttable.auto_recover_status = "waiting"
-                end
+              @rttable.auto_recover_status = 'executing'
+              begin
+                @log.debug('auto recover start')
+                acquired_recover_process
+              rescue => e
+                @log.error("#{__method__}:#{e.inspect} #{$ERROR_POSITION}")
+              ensure
+                @stats.run_recover = false
+                @rttable.auto_recover_status = 'waiting'
+              end
             when :no_action
-              @log.debug("auto recover NOT start. Because lost action is [no_action]")
+              @log.debug('auto recover NOT start. Because lost action is [no_action]')
           end
         end
       end
@@ -344,11 +342,11 @@ module Roma
         @stats.run_release = true
         @stats.run_iterate_storage = true
         @stats.spushv_protection = true
-        t = Thread::new do
+        t = Thread.new do
           begin
             release_process
           rescue => e
-            @log.error("#{__method__}:#{e.inspect} #{$@}")
+            @log.error("#{__method__}:#{e.inspect} #{$ERROR_POSITION}")
           ensure
             @stats.run_iterate_storage = false
             @stats.run_release = false
@@ -368,7 +366,7 @@ module Roma
         break unless @do_acquired_recover_process
         break if @rttable.num_of_vn(@stats.ap_str)[2] == 0 # short vnodes
 
-        vn, nodes, is_primary = @rttable.select_vn_for_recover(exclude_nodes)
+        vn, nodes, is_primary = @rttable.select_vn_for_recover(exclude_nodes, @stats.rep_host)
         break unless vn
 
         if nodes.length != 0
@@ -383,7 +381,7 @@ module Roma
       end
       @log.info("#{__method__} has done.")
     rescue => e
-      @log.error("#{e.inspect} #{$@}")
+      @log.error("#{e.inspect} #{$ERROR_POSITION}")
     ensure
       @do_acquired_recover_process = false
     end
@@ -395,10 +393,10 @@ module Roma
       exclude_nodes = @rttable.exclude_nodes_for_join(@stats.ap_str, @stats.rep_host)
 
       @do_join_process = true
-      while (@rttable.vnode_balance(@stats.ap_str) == :less && count < nv) do
+      while @rttable.vnode_balance(@stats.ap_str) == :less && count < nv
         break unless @do_join_process
 
-        vn, nodes, is_primary = @rttable.select_vn_for_join(exclude_nodes)
+        vn, nodes, is_primary = @rttable.select_vn_for_join(exclude_nodes, @stats.rep_host)
         unless vn
           @log.warn("#{__method__}:vnode does not found")
           return false
@@ -412,7 +410,7 @@ module Roma
         end
       end
     rescue => e
-      @log.error("#{e.inspect} #{$@}")
+      @log.error("#{e.inspect} #{$ERROR_POSITION}")
     ensure
       @log.info("#{__method__} has done.")
       @do_join_process = false
@@ -425,10 +423,10 @@ module Roma
       exclude_nodes = @rttable.exclude_nodes_for_balance(@stats.ap_str, @stats.rep_host)
 
       @do_balance_process = true
-      while (@rttable.vnode_balance(@stats.ap_str) == :less && count < nv) do
+      while @rttable.vnode_balance(@stats.ap_str) == :less && count < nv
         break unless @do_balance_process
 
-        vn, nodes, is_primary = @rttable.select_vn_for_balance(exclude_nodes)
+        vn, nodes, is_primary = @rttable.select_vn_for_balance(exclude_nodes, @stats.rep_host)
         unless vn
           @log.warn("#{__method__}:vnode does not found")
           return false
@@ -443,7 +441,7 @@ module Roma
       end
       @log.info("#{__method__} has done.")
     rescue => e
-      @log.error("#{e.inspect} #{$@}")
+      @log.error("#{e.inspect} #{$ERROR_POSITION}")
     ensure
       @do_balance_process = false
     end
@@ -454,16 +452,16 @@ module Roma
       res = con.gets # receive 'PUSHED\r\n' | 'REJECTED\r\n' | 'ERROR\r\n'
       if res == "REJECTED\r\n"
         @log.warn("#{__method__}:request was rejected from #{src_nid}.")
-        Roma::Messaging::ConPool.instance.return_connection(src_nid,con)
+        Roma::Messaging::ConPool.instance.return_connection(src_nid, con)
         return :rejected
       elsif res != "PUSHED\r\n"
         @log.warn("#{__method__}:#{res}")
         return :rejected
       end
-      Roma::Messaging::ConPool.instance.return_connection(src_nid,con)
+      Roma::Messaging::ConPool.instance.return_connection(src_nid, con)
       # waiting for pushv
       count = 0
-      while @rttable.search_nodes(vn).include?(@stats.ap_str)==false && count < @stats.reqpushv_timeout_count
+      while @rttable.search_nodes(vn).include?(@stats.ap_str) == false && count < @stats.reqpushv_timeout_count
         sleep 0.1
         count += 1
       end
@@ -472,8 +470,8 @@ module Roma
         return :timeout
       end
       true
-    rescue =>e
-      @log.error("#{__method__}:#{e.inspect} #{$@}")
+    rescue => e
+      @log.error("#{__method__}:#{e.inspect} #{$ERROR_POSITION}")
       @rttable.proc_failed(src_nid)
       false
     end
@@ -487,7 +485,7 @@ module Roma
       end
 
       @do_release_process = true
-      while(@rttable.has_node?(@stats.ap_str)) do
+      while @rttable.has_node?(@stats.ap_str)
         break unless @do_release_process
         @rttable.each_vnode do |vn, nids|
           break unless @do_release_process
@@ -507,8 +505,8 @@ module Roma
         end
       end
       @log.info("#{__method__} has done.")
-    rescue =>e
-      @log.error("#{e}\n#{$@}")
+    rescue => e
+      @log.error("#{e}\n#{$ERROR_POSITION}")
     ensure
       @do_release_process = false
       Roma::Messaging::ConPool.instance.close_all
@@ -517,23 +515,23 @@ module Roma
     def sync_a_vnode_for_release(vn, to_nid, new_nids)
       nids = @rttable.search_nodes(vn)
 
-      if nids.include?(to_nid)==false
+      if nids.include?(to_nid) == false
         @log.debug("#{__method__}:#{vn} #{to_nid}")
         # change routing data at the vnode and synchronize a data
         nids << to_nid
         return false unless @rttable.transaction(vn, nids)
 
         # synchronize a data
-        @storages.each_key{ |hname|
+        @storages.each_key do |hname|
           res = push_a_vnode_stream(hname, vn, to_nid)
 
-          if res != "STORED"
+          if res != 'STORED'
             @rttable.rollback(vn)
             @log.error("#{__method__}:push_a_vnode was failed:hname=#{hname} vn=#{vn}:#{res}")
-            return :abort if res.start_with?("SERVER_ERROR")
+            return :abort if res.start_with?('SERVER_ERROR')
             return false
           end
-        }
+        end
 
         if (clk = @rttable.commit(vn)) == false
           @rttable.rollback(vn)
@@ -543,40 +541,40 @@ module Roma
 
         clk = @rttable.set_route(vn, clk, new_nids)
         if clk.is_a?(Integer) == false
-          clk,new_nids = @rttable.search_nodes_with_clk(vn)
+          clk, new_nids = @rttable.search_nodes_with_clk(vn)
         end
 
         cmd = "setroute #{vn} #{clk - 1}"
-        new_nids.each{ |nn| cmd << " #{nn}"}
+        new_nids.each { |nn| cmd << " #{nn}" }
         res = async_broadcast_cmd("#{cmd}\r\n")
         @log.debug("#{__method__}:async_broadcast_cmd(#{cmd}) #{res}")
       end
 
       return true
-    rescue =>e
-      @log.error("#{e}\n#{$@}")
+    rescue => e
+      @log.error("#{e}\n#{$ERROR_POSITION}")
       false
     end
 
-    def sync_a_vnode(vn, to_nid, is_primary=nil)
+    def sync_a_vnode(vn, to_nid, is_primary = nil)
       nids = @rttable.search_nodes(vn)
 
-      if nids.include?(to_nid)==false || (is_primary && nids[0]!=to_nid)
+      if nids.include?(to_nid) == false || (is_primary && nids[0] != to_nid)
         @log.debug("#{__method__}:#{vn} #{to_nid} #{is_primary}")
         # change routing data at the vnode and synchronize a data
         nids << to_nid
         return false unless @rttable.transaction(vn, nids)
 
         # synchronize a data
-        @storages.each_key{ |hname|
+        @storages.each_key do |hname|
           res = push_a_vnode_stream(hname, vn, to_nid)
 
-          if res != "STORED"
+          if res != 'STORED'
             @rttable.rollback(vn)
             @log.error("#{__method__}:push_a_vnode was failed:hname=#{hname} vn=#{vn}:#{res}")
             return false
           end
-        }
+        end
 
         if (clk = @rttable.commit(vn)) == false
           @rttable.rollback(vn)
@@ -587,27 +585,27 @@ module Roma
         nids = edit_nodes(nids, to_nid, is_primary)
         clk = @rttable.set_route(vn, clk, nids)
         if clk.is_a?(Integer) == false
-          clk,nids = @rttable.search_nodes_with_clk(vn)
+          clk, nids = @rttable.search_nodes_with_clk(vn)
         end
 
         cmd = "setroute #{vn} #{clk - 1}"
-        nids.each{ |nn| cmd << " #{nn}"}
+        nids.each { |nn| cmd << " #{nn}" }
         res = async_broadcast_cmd("#{cmd}\r\n")
         @log.debug("#{__method__}:async_broadcast_cmd(#{cmd}) #{res}")
       else
         # synchronize a data
-        @storages.each_key{ |hname|
+        @storages.each_key do |hname|
           res = push_a_vnode_stream(hname, vn, to_nid)
-          if res != "STORED"
+          if res != 'STORED'
             @log.error("#{__method__}:push_a_vnode was failed:hname=#{hname} vn=#{vn}:#{res}")
             return false
           end
-        }
+        end
       end
 
       return true
-    rescue =>e
-      @log.error("#{e}\n#{$@}")
+    rescue => e
+      @log.error("#{e}\n#{$ERROR_POSITION}")
       false
     end
 
@@ -636,7 +634,7 @@ module Roma
 
       if is_primary
         # [new_nid, node_a]
-        nodes.insert(0,new_nid)
+        nodes.insert(0, new_nid)
       else
         # [node_a, new_nid]
         nodes << new_nid
@@ -666,64 +664,63 @@ module Roma
         unless @do_push_a_vnode_stream
           con.close
           @log.error("#{__method__}:canceled in hname=#{hname} vn=#{vn} nid=#{nid}")
-          return "CANCELED"
+          return 'CANCELED'
         end
 
         con.write(data)
         sleep @stats.stream_copy_wait_param
       end
-      con.write("\0"*20) # end of steram
+      con.write("\0" * 20) # end of steram
 
       res = con.gets # STORED\r\n or error string
-      Roma::Messaging::ConPool.instance.return_connection(nid,con)
+      Roma::Messaging::ConPool.instance.return_connection(nid, con)
       res.chomp! if res
       if res_dump == false
         @log.error("#{__method__}:each_vn_dump in hname=#{hname} vn=#{vn} nid=#{nid}")
-        return "CANCELED"
+        return 'CANCELED'
       end
       res
-    rescue =>e
-      @log.error("#{e}\n#{$@}")
+    rescue => e
+      @log.error("#{e}\n#{$ERROR_POSITION}")
       e.to_s
     end
 
-
-    def asyncev_start_storage_clean_up_process(args)
-#      @log.info("#{__method__}")
+    def asyncev_start_storage_clean_up_process(_args)
+      #      @log.info("#{__method__}")
       if @stats.run_storage_clean_up
         @log.error("#{__method__}:already in being")
         return
       end
       @stats.run_storage_clean_up = true
-      t = Thread::new{
+      t = Thread.new do
         begin
           storage_clean_up_process
-        rescue =>e
-          @log.error("#{__method__}:#{e.inspect} #{$@}")
+        rescue => e
+          @log.error("#{__method__}:#{e.inspect} #{$ERROR_POSITION}")
         ensure
           @stats.last_clean_up = Time.now
           @stats.run_storage_clean_up = false
         end
-      }
+      end
       t[:name] = __method__
     end
 
     def storage_clean_up_process
       @log.info("#{__method__}:start")
       me = @stats.ap_str
-      vnhash={}
+      vnhash = {}
       @rttable.each_vnode do |vn, nids|
         if nids.include?(me)
           if nids[0] == me
             vnhash[vn] = :primary
           else
-            vnhash[vn] = :secondary
+            vnhash[vn] = "secondary#{nids.index(me)}".to_sym
           end
         end
       end
       t = Time.now.to_i - Roma::Config::STORAGE_DELMARK_EXPTIME
       count = 0
-      @storages.each_pair do |hname,st|
+      @storages.each_pair do |hname, st|
         break unless @stats.do_clean_up?
         st.each_clean_up(t, vnhash) do |key, vn|
           # @log.debug("#{__method__}:key=#{key} vn=#{vn}")
@@ -733,7 +730,7 @@ module Roma
             nodes = @rttable.search_nodes_for_write(vn)
             if nodes && nodes.length > 1
               nodes[1..-1].each do |nid|
-                res = async_send_cmd(nid,"out #{key}\e#{hname} #{vn}\r\n")
+                res = async_send_cmd(nid, "out #{key}\e#{hname} #{vn}\r\n")
                 unless res
                   @log.warn("send out command failed:#{key}\e#{hname} #{vn} -> #{nid}")
                 end
@@ -746,7 +743,7 @@ module Roma
           end
         end
       end
-      if count>0
+      if count > 0
         @log.info("#{__method__}:#{count} keys deleted.")
       end
 
@@ -763,46 +760,46 @@ module Roma
     end
 
     def asyncev_calc_latency_average(args)
-      latency,cmd = args
-      #@log.debug(__method__)
-
-      if !@stats.latency_data.key?(cmd) #only first execute target cmd
-        @stats.latency_data[cmd].store("latency", Array.new())
-        @stats.latency_data[cmd].store("latency_max", Hash.new())
-        @stats.latency_data[cmd]["latency_max"].store("current", 0)
-        @stats.latency_data[cmd].store("latency_min", Hash.new())
-        @stats.latency_data[cmd]["latency_min"].store("current", 99999)
-        @stats.latency_data[cmd].store("time", Time.now.to_i)
+      latency, cmd = args
+      # @log.debug(__method__)
+
+      unless @stats.latency_data.key?(cmd) # only first execute target cmd
+        @stats.latency_data[cmd].store('latency', [])
+        @stats.latency_data[cmd].store('latency_max', {})
+        @stats.latency_data[cmd]['latency_max'].store('current', 0)
+        @stats.latency_data[cmd].store('latency_min', {})
+        @stats.latency_data[cmd]['latency_min'].store('current', 99_999)
+        @stats.latency_data[cmd].store('time', Time.now.to_i)
       end
 
       begin
-        @stats.latency_data[cmd]["latency"].delete_at(0) if @stats.latency_data[cmd]["latency"].length >= 10
-        @stats.latency_data[cmd]["latency"].push(latency)
+        @stats.latency_data[cmd]['latency'].delete_at(0) if @stats.latency_data[cmd]['latency'].length >= 10
+        @stats.latency_data[cmd]['latency'].push(latency)
 
-        @stats.latency_data[cmd]["latency_max"]["current"] = latency if latency > @stats.latency_data[cmd]["latency_max"]["current"]
-        @stats.latency_data[cmd]["latency_min"]["current"] = latency if latency < @stats.latency_data[cmd]["latency_min"]["current"]
+        @stats.latency_data[cmd]['latency_max']['current'] = latency if latency > @stats.latency_data[cmd]['latency_max']['current']
+        @stats.latency_data[cmd]['latency_min']['current'] = latency if latency < @stats.latency_data[cmd]['latency_min']['current']
 
-      rescue =>e
-        @log.error("#{__method__}:#{e.inspect} #{$@}")
+      rescue => e
+        @log.error("#{__method__}:#{e.inspect} #{$ERROR_POSITION}")
 
       ensure
-        if @stats.latency_check_time_count && Time.now.to_i - @stats.latency_data[cmd]["time"] > @stats.latency_check_time_count
-          average = @stats.latency_data[cmd]["latency"].inject(0.0){|r,i| r+=i }/@stats.latency_data[cmd]["latency"].size
-          max = @stats.latency_data[cmd]["latency_max"]["current"]
-          min = @stats.latency_data[cmd]["latency_min"]["current"]
-          @log.debug("Latency average[#{cmd}]: #{sprintf("%.8f", average)}"+
-                     "(denominator=#{@stats.latency_data[cmd]["latency"].length}"+
-                     " max=#{sprintf("%.8f", max)}"+
-                     " min=#{sprintf("%.8f", min)})"
+        if @stats.latency_check_time_count && Time.now.to_i - @stats.latency_data[cmd]['time'] > @stats.latency_check_time_count
+          average = @stats.latency_data[cmd]['latency'].inject(0.0) { |r, i| r += i } / @stats.latency_data[cmd]['latency'].size
+          max = @stats.latency_data[cmd]['latency_max']['current']
+          min = @stats.latency_data[cmd]['latency_min']['current']
+          @log.debug("Latency average[#{cmd}]: #{sprintf('%.8f', average)}"\
+                     "(denominator=#{@stats.latency_data[cmd]['latency'].length}"\
+                     " max=#{sprintf('%.8f', max)}"\
+                     " min=#{sprintf('%.8f', min)})"
                     )
 
-          @stats.latency_data[cmd]["time"] =  Time.now.to_i
-          @stats.latency_data[cmd]["latency_past"] = @stats.latency_data[cmd]["latency"]
-          @stats.latency_data[cmd]["latency"] = []
-          @stats.latency_data[cmd]["latency_max"]["past"] = @stats.latency_data[cmd]["latency_max"]["current"]
-          @stats.latency_data[cmd]["latency_max"]["current"] = 0
-          @stats.latency_data[cmd]["latency_min"]["past"] = @stats.latency_data[cmd]["latency_min"]["current"]
-          @stats.latency_data[cmd]["latency_min"]["current"] = 99999
+          @stats.latency_data[cmd]['time'] =  Time.now.to_i
+          @stats.latency_data[cmd]['latency_past'] = @stats.latency_data[cmd]['latency']
+          @stats.latency_data[cmd]['latency'] = []
+          @stats.latency_data[cmd]['latency_max']['past'] = @stats.latency_data[cmd]['latency_max']['current']
+          @stats.latency_data[cmd]['latency_max']['current'] = 0
+          @stats.latency_data[cmd]['latency_min']['past'] = @stats.latency_data[cmd]['latency_min']['current']
+          @stats.latency_data[cmd]['latency_min']['current'] = 99_999
         end
       end
       true
@@ -817,13 +814,13 @@ module Roma
         @log.error("Can not flush storage. stat = #{st.dbs[dn]}")
         return true
       end
-      t = Thread::new do
+      t = Thread.new do
         begin
           st.flush_db(dn)
-          st.set_db_stat(dn,:safecopy_flushed)
+          st.set_db_stat(dn, :safecopy_flushed)
           @log.info("#{__method__}:storage has flushed. (#{hname}, #{dn})")
-        rescue =>e
-          @log.error("#{__method__}:#{e.inspect} #{$@}")
+        rescue => e
+          @log.error("#{__method__}:#{e.inspect} #{$ERROR_POSITION}")
         ensure
         end
       end
@@ -840,11 +837,11 @@ module Roma
         @log.error("Can not start cachecleaning process. stat = #{st.dbs[dn]}")
         return true
       end
-      t = Thread::new do
+      t = Thread.new do
         begin
           storage_cachecleaning_process(hname, dn)
-        rescue =>e
-          @log.error("#{__method__}:#{e.inspect} #{$@}")
+        rescue => e
+          @log.error("#{__method__}:#{e.inspect} #{$ERROR_POSITION}")
         ensure
         end
       end
@@ -861,7 +858,7 @@ module Roma
       loop do
         # get keys in a cache up to 100 kyes
         keys = st.get_keys_in_cache(dn)
-        break if keys == nil || keys.length == 0
+        break if keys.nil? || keys.length == 0
         break unless @do_storage_cachecleaning_process
 
         # @log.debug("#{__method__}:#{keys.length} keys found")
@@ -884,7 +881,7 @@ module Roma
       if @do_storage_cachecleaning_process == false
         @log.warn("#{__method__}:uncompleted")
       else
-        st.set_db_stat(dn,:normal)
+        st.set_db_stat(dn, :normal)
       end
       @log.debug("#{__method__}:#{count} keys loaded.")
       @log.debug("#{__method__}:#{rcount} keys rejected.") if rcount > 0
@@ -894,11 +891,11 @@ module Roma
 
     def asyncev_start_get_routing_event(args)
       @log.debug("#{__method__} #{args}")
-      t = Thread::new do
+      t = Thread.new do
         begin
           get_routing_event
         rescue => e
-          @log.error("#{__method__}:#{e.inspect} #{$@}")
+          @log.error("#{__method__}:#{e.inspect} #{$ERROR_POSITION}")
         ensure
         end
       end
@@ -911,27 +908,27 @@ module Roma
       routing_path = Config::RTTABLE_PATH
       f_list = Dir.glob("#{routing_path}/#{@stats.ap_str}*")
 
-      f_list.each{|fname|
-        IO.foreach(fname){|line|
+      f_list.each do|fname|
+        IO.foreach(fname)do|line|
           if line =~ /join|leave/
             @rttable.event.shift if @rttable.event.size >= @rttable.event_limit_line
-            @rttable.event << line.chomp 
+            @rttable.event << line.chomp
           end
-        }
-      }
+        end
+      end
 
       @log.info("#{__method__} has done.")
-    rescue =>e
-      @log.error("#{e}\n#{$@}")
+    rescue => e
+      @log.error("#{e}\n#{$ERROR_POSITION}")
     end
 
     def asyncev_start_get_logs(args)
       @log.debug("#{__method__} #{args}")
-      t = Thread::new do
+      t = Thread.new do
         begin
           get_logs(args)
         rescue => e
-          @log.error("#{__method__}:#{e.inspect} #{$@}")
+          @log.error("#{__method__}:#{e.inspect} #{$ERROR_POSITION}")
         ensure
           @stats.gui_run_gather_logs = false
         end
@@ -946,7 +943,7 @@ module Roma
       log_file = "#{log_path}/#{@stats.ap_str}.log"
 
       target_logs = []
-      File.open(log_file){|f|
+      File.open(log_file)do|f|
         start_point = get_point(f, args[0], 'start')
         end_point = get_point(f, args[1], 'end')
 
@@ -955,26 +952,26 @@ module Roma
         target_logs = f.read(end_point - start_point)
         target_logs = target_logs.each_line.map(&:chomp)
         target_logs.delete('.')
-      }
+      end
 
       @rttable.logs = target_logs
       # set gathered date for expiration
       @rttable.logs.unshift(Time.now)
 
       @log.debug("#{__method__} has done.")
-    rescue =>e
+    rescue => e
       @rttable.logs = []
-      @log.error("#{e}\n#{$@}")
+      @log.error("#{e}\n#{$ERROR_POSITION}")
     ensure
       @stats.gui_run_gather_logs = false
     end
 
-    def get_point(f, target_time, type, latency_time=Time.now, current_pos=0, new_pos=f.size/2)
+    def get_point(f, target_time, type, latency_time = Time.now, current_pos = 0, new_pos = f.size / 2)
       # hilatency check
-      ps = Time.now - latency_time 
+      ps = Time.now - latency_time
       if ps > 5
-        @log.warn("gather_logs process was failed.")
-        raise
+        @log.warn('gather_logs process was failed.')
+        fail
       end
 
       # initialize read size
@@ -986,33 +983,33 @@ module Roma
         return f.size if target_time == 'current'
 
         target_time =~ (/(\d+)-(\d+)-(\d+)T(\d+):(\d+):(\d+)/)
-        target_time = Time.mktime($1, $2, $3, $4, $5, $6, 000000)
- 
+        target_time = Time.mktime(Regexp.last_match[1], Regexp.last_match[2], Regexp.last_match[3], Regexp.last_match[4], Regexp.last_match[5], Regexp.last_match[6], 000000)
+
         # check outrange or not
         f.seek(0, IO::SEEK_SET)
         begining_log = f.read(read_size)
         pos = begining_log.index(/[IDEW],\s\[(\d+)-(\d+)-(\d+)T(\d+):(\d+):(\d+)\.(\d+)/)
-        begining_time = Time.mktime($1, $2, $3, $4, $5, $6, $7)
+        begining_time = Time.mktime(Regexp.last_match[1], Regexp.last_match[2], Regexp.last_match[3], Regexp.last_match[4], Regexp.last_match[5], Regexp.last_match[6], Regexp.last_match[7])
 
         f.seek(-read_size, IO::SEEK_END)
         end_log = f.read(read_size)
         pos = end_log.rindex(/[IDEW],\s\[(\d+)-(\d+)-(\d+)T(\d+):(\d+):(\d+)\.(\d+)/)
-        end_time = Time.mktime($1, $2, $3, $4, $5, $6, $7)
+        end_time = Time.mktime(Regexp.last_match[1], Regexp.last_match[2], Regexp.last_match[3], Regexp.last_match[4], Regexp.last_match[5], Regexp.last_match[6], Regexp.last_match[7])
 
         case type
         when 'start'
           if target_time < begining_time
             return 0
           elsif target_time > end_time
-            @log.error("irregular time was set.")
-            raise
+            @log.error('irregular time was set.')
+            fail
           end
         when 'end'
           if target_time > end_time
             return f.size
           elsif target_time < begining_time
-            @log.error("irregular time was set.")
-            raise
+            @log.error('irregular time was set.')
+            fail
           end
         end
       end
@@ -1024,20 +1021,20 @@ module Roma
       date_a = sector_log.scan(/[IDEW],\s\[(\d+)-(\d+)-(\d+)T(\d+):(\d+):(\d+)\.(\d+)/)
 
       time_a = []
-      date_a.each{|time|
+      date_a.each do|time|
         time_a.push(Time.mktime(time[0], time[1], time[2], time[3], time[4], time[5], time[6]))
-      }
+      end
       sector_time_first = time_a[0]
       sector_time_last = time_a[-1]
- 
+
       if target_time.between?(sector_time_first, sector_time_last)
-        time_a.each{|time|
+        time_a.each do|time|
           if target_time <= time
-            time_string = time.strftime("%Y-%m-%dT%H:%M:%S")
+            time_string = time.strftime('%Y-%m-%dT%H:%M:%S')
             target_index = sector_log.index(/[IDEW],\s\[#{time_string}/)
             return new_pos + target_index
-          end 
-        }
+          end
+        end
       elsif sector_time_first > target_time
         target_pos = new_pos - ((new_pos - current_pos).abs / 2)
       elsif sector_time_first < target_time
@@ -1046,7 +1043,5 @@ module Roma
 
       get_point(f, target_time, type, latency_time, new_pos, target_pos)
     end
-
   end # module AsyncProcess
-
 end # module Roma