roma 0.8.2

data/lib/roma/tools/simple_bench.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+require 'date'
+require 'roma/client/rclient'
+
+@@cnt=0
+@@tmax=0
+@@tmin=100
+
+Thread.new {
+  sleep_time=10
+  while(true)
+    sleep sleep_time
+    printf("qps=%d max=%f min=%f ave=%f\n",@@cnt/sleep_time,@@tmax,@@tmin,sleep_time/@@cnt.to_f)
+    @@cnt=0
+    @@tmax=0
+    @@tmin=100
+  end
+}
+
+def random_rquest_sender(ini_nodes)
+  rc=Roma::Client::RomaClient.new(ini_nodes)
+
+  n=10000
+  loop{
+    i=rand(n)
+    ts = DateTime.now
+    case rand(3)
+    when 0
+      res=rc.set(i.to_s,'hoge'+i.to_s)
+      puts "set k=#{i} #{res}" if res==nil || res.chomp != 'STORED'
+    when 1
+      res=rc.get(i.to_s)
+      puts "get k=#{i} #{res}" if res == :error
+    when 2
+      res=rc.delete(i.to_s)
+      puts "del k=#{i} #{res}" if res != 'DELETED' && res != 'NOT_FOUND'
+    end
+    t=(DateTime.now - ts).to_f * 86400.0
+    @@tmax=t if t > @@tmax
+    @@tmin=t if t < @@tmin
+    @@cnt+=1
+  }
+end
+ 
+if ARGV.length == 0
+  STDERR.puts "usage:simple_bench addr:port"
+  exit
+end
+
+tn=10
+t=[]
+tn.times{
+  t << Thread.new{
+    random_rquest_sender(ARGV)
+  }
+}
+

data/lib/roma/tools/ssroute.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+#
+# usage:ssroute address_port
+#
+require 'roma/routing/routing_data'
+
+if ARGV.length!=1
+  puts "usage:ssroute address:port"
+  exit
+end
+
+ap = ARGV[0].sub(':','_')
+
+begin
+  if Roma::Routing::RoutingData::snapshot("#{ap}.route")
+    puts "succeed"
+  else
+    puts "Routing-log file dose not found."
+  end
+rescue =>e
+  puts "error:#{e}"
+end

data/lib/roma/tools/tribunus.rb

@@ -0,0 +1,299 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+require 'socket'
+require 'ipaddr'
+require 'optparse'
+UDP_PORT=14329
+MULTICAST_ADDR="225.0.0.123"
+ROMA_LOAD_PATH=File.expand_path(File.join(File.dirname(__FILE__),"../.."))
+RUBY_COMMAND_OPTIONS=["-I",ROMA_LOAD_PATH]
+ROMAD_OPTIONS=["--enabled_repeathost"]
+bin_dir=File.expand_path(File.join(File.dirname(__FILE__),"../../../bin"))
+ROMAD_PATH= File.expand_path(File.join(bin_dir,"romad"))
+MKROUTE_PATH= File.expand_path(File.join(bin_dir,"mkroute"))
+
+ROMAD_WORK_DIR='.'
+class Tribunus
+  #protocol
+  #
+  #update:<reply_ocunt>: <romad_hostname> [<romad_port> ...]
+
+  RomadHost=Struct.new(:hostname,:ports,:updated_at)
+  def log(obj)
+    if @verbose
+      if obj.is_a? String
+        $stderr.puts obj
+      else
+        $stderr.puts obj.inspect
+      end
+    end
+  end
+  private :log
+
+  def initialize(romad_hostname,romad_ports,options={})
+    @multi_addr=options[:multicast_addr]||MULTICAST_ADDR
+    @port=options[:udp_port]||UDP_PORT
+    @romad_work_dir=options[:romad_work_dir]||ROMAD_WORK_DIR
+    @ruby_command_name=options[:ruby_command_name]||"ruby"
+    @verbose=options[:verbose]
+    log [:initalized,@multi_addr,@port,@romad_work_dir,@ruby_command_name]
+
+    @threads=[]
+    @romads={} #port => pid
+    @local_romad_host=RomadHost.new(romad_hostname,romad_ports,nil)
+
+    @mutex=Mutex.new
+    @remote_servers={} #ipaddr => RomadHost
+
+  end
+  
+  def from_remote?(ipaddr)
+      from_remote= !Socket.ip_address_list.any?{|addr|addr.ip_address==ipaddr}
+  end
+  private :from_remote?
+
+
+  def spawn_new_roma_ring
+    spawn_romads(nil,nil)
+  end
+
+
+  def spawn_romads(remote_host,remote_port)
+    nodes=@local_romad_host.ports.map do|port|
+      "#{@local_romad_host.hostname}_#{port}"
+    end
+    nodes << "#{remote_host}_#{remote_port}" if remote_host
+    pid=Process.spawn(@ruby_command_name,*RUBY_COMMAND_OPTIONS,MKROUTE_PATH,*nodes,:chdir=>@romad_work_dir)
+    if(Process.waitpid2(pid)[1].to_i!=0)
+      raise "failed to make route"
+    end
+    
+    @local_romad_host.ports.each do|port|
+      pid=Process.spawn(@ruby_command_name,*RUBY_COMMAND_OPTIONS,ROMAD_PATH,*ROMAD_OPTIONS,"-p",port.to_s,@local_romad_host.hostname, :chdir=>@romad_work_dir)
+      @romads[port]=pid
+    end
+  end
+
+  def spawn_romads_join(remote_host,remote_port)
+    @local_romad_host.ports.map do|port|
+      spawn_romad_join(port,remote_host,remote_port)
+    end
+  end
+
+
+  def spawn_romad_join(port,remote_host,remote_port)
+    pid=Process.spawn(@ruby_command_name,*RUBY_COMMAND_OPTIONS,ROMAD_PATH,*ROMAD_OPTIONS,"-p",port.to_s,@local_romad_host.hostname,"-j","#{remote_host}_#{remote_port}",:chdir=>@romad_work_dir)
+    @romads[port]=pid
+  end
+
+
+  def receive_update_command(ipaddr,reply_count,params)
+    param_ary=params.strip.split(/\s+/)
+    unless param_ary.empty?
+      hostname=param_ary[0]
+      ports=param_ary[1..-1].map{|port| port.to_i}
+      rhost=RomadHost.new(hostname,ports,Time.now)
+      @remote_servers[ipaddr]=rhost
+      if reply_count>0
+        unicast(ipaddr,update_message(reply_count-1))
+      end
+    end
+  end
+
+  def run_command(ipaddr,msg)
+    match_data=/\A(.*):(\d+):(.*)/.match(msg)
+    if(match_data)
+      command=match_data[1]
+      reply_count=match_data[2].to_i
+      rest=match_data[3]
+      case command
+      when "update"
+        receive_update_command(ipaddr,reply_count,rest)
+      end
+    end
+  end
+  private :run_command
+
+  def update_message(reply_count,initial=false)
+    msg="update:#{reply_count}: #{@local_romad_host.hostname}"
+    if !initial && !@romads.keys.empty?
+      msg+=" "
+      msg+= @romads.keys.join(' ')
+    end
+    log [:msg, msg,@romads]
+    msg
+  end
+
+  def server_loop
+    sock=UDPSocket.new
+    sock.bind('0.0.0.0',@port)
+    sock.setsockopt(Socket::IPPROTO_IP, Socket::IP_ADD_MEMBERSHIP, IPAddr.new(MULTICAST_ADDR).hton+IPAddr.new('0.0.0.0').hton)
+    log 'start_listen'
+    Socket.udp_server_loop_on([sock]) do|msg,msg_src|
+        log [:received ,msg,msg_src]
+      if from_remote?(msg_src.remote_address.ip_address)
+        run_command(msg_src.remote_address.ip_address,msg)
+      end
+    end
+  end
+
+  HEARTBEAT_SECONDS=300
+  HEARTBEAT_LOOP_INTERVAL=50
+  TIMEOUT_SECONDS=600
+
+
+  def heartbeat_loop
+    loop do
+      delete_ipaddrs=[]
+      @remote_servers.each do|ipaddr,host|
+
+        if host.updated_at+TIMEOUT_SECONDS < Time.now
+          delete_ipaddrs << ipaddr
+        elsif host.updated_at+HEARTBEAT_SECONDS < Time.now
+          unicast(ipaddr,update_message(0))
+        elsif host.ports.empty?
+          unicast(ipaddr,update_message(1))
+        end
+      end
+
+      @mutex.synchronize do
+        delete_ipaddrs.each do|ipaddr|
+          @remote_servers.delete(ipaddr)
+        end
+      end
+
+
+      
+
+      sleep(HEARTBEAT_LOOP_INTERVAL)
+    end
+  rescue =>e
+    p e
+  end
+
+  def set_trap
+    [:INT,:TERM,:HUP].each do|sig|
+      Signal.trap(sig){ Process.kill(sig,*@romads.values);exit(1)  }
+    end
+  end
+
+  def prepare_to_start
+    set_trap
+    @threads << Thread.start{self.server_loop}
+    @threads << Thread.start{self.heartbeat_loop}
+  end
+  private :prepare_to_start
+
+  def start_new_ring
+    prepare_to_start
+    spawn_new_roma_ring
+  end
+
+  def choose_rhost
+    @remote_servers.each do|ipaddr,rhost|
+      unless rhost.ports.empty?
+        return rhost
+      end
+    end
+    nil
+  end
+  def start_join(host,port)
+    prepare_to_start
+    sleep(0.2)
+    spawn_romads_join(host,port)
+  end
+
+  def start_discover
+    prepare_to_start
+    sleep(0.2)
+    multicast(update_message(1,true))
+    10.times{sleep(0.3)}
+    rhost=choose_rhost
+    if rhost
+      spawn_romads_join(rhost.hostname,rhost.ports.first)
+    else
+      $stderr.puts "no server responded"
+      exit 1
+    end
+
+  end
+
+  def join
+    @threads.each{|t|t.join}
+  end
+
+  def unicast(ipaddr,msg)
+    log [:message, ipaddr,msg]
+    s=UDPSocket.new
+    begin
+      s.connect(ipaddr,@port)
+      s.sendmsg(msg)
+    ensure
+        s.close
+    end
+  end
+
+  def multicast(msg)
+    unicast(@multi_addr,msg)
+  end
+end
+
+opt=OptionParser.new
+conf={}
+opt.on('-d','discover the node by multicast [default]') do|v|
+  conf[:mode]=:discover
+end
+opt.on('-c','craete new ring') do|v|
+  conf[:mode]=:new_ring
+end
+opt.on('-j HOST:PORT',/\A.+?[_:]\d+\Z/,'join the specified romad node') do|v|
+  conf[:mode]=:join
+  node=v.split(/[_:]/)
+  conf[:joining_node]=[node[0],node[1].to_i]
+end
+
+opt.on('-p UDP_PORT',/\A\d+\Z/,'the port for multicast') do|v|
+  conf[:udp_port]=v.to_i
+end
+opt.on('-w WORKING_DIR','the directory where romads run') do|v|
+  conf[:romad_work_dir]=v
+end
+opt.on('-m MULTICAST_ADDRESS',/\A\d+\.\d+\.\d+\.\d+\Z/,'the ip address for multicast') do|v|
+  conf[:multicast_addr]=v
+end
+opt.on('-r RUBY_COMMAND','name of ruby interpreter (default: "ruby")') do|v|
+  conf[:ruby_command_name]=v
+end
+opt.on('-v','--verbose') do|v|
+  conf[:verbose]=v
+end
+opt.banner += " hostname port_range"
+
+opt.parse!(ARGV)
+
+if ARGV.size!=2
+  puts opt.help
+  exit 1
+end
+hostname=ARGV[0]
+port_ary=ARGV[1].split('-')
+ports=(port_ary[0].to_i..port_ary[1].to_i).to_a
+if ports.size < 2
+  puts 'less ports'
+  exit 1
+end
+if ports.size >100
+  puts 'too many ports'
+  exit 1
+end
+
+tri=Tribunus.new(hostname,ports,conf)
+case conf[:mode] 
+when:new_ring
+  tri.start_new_ring
+when :join 
+  tri.start_join(conf[:joining_node][0],conf[:joining_node][1])
+else
+  tri.start_discover
+end
+tri.join

data/lib/roma/version.rb

@@ -0,0 +1,4 @@
+
+module Roma
+  VERSION = "0.8.2"
+end

data/lib/roma/write_behind.rb

@@ -0,0 +1,179 @@
+require 'thread'
+require 'roma/stats'
+
+module Roma
+
+  module WriteBehind
+    
+    class FileWriter
+
+      def initialize(path, shift_size, log)
+        @stats = Roma::Stats.instance
+        path.chop! if path[-1]=='/'
+        @path = path
+        @log = log
+        @fdh = {} # file handle hash
+        @fnh = {} # file name hash
+        @do_write = false
+        @shift_size = shift_size
+        @total_size = Hash.new(0)
+        @rottime = Time.now
+      end
+
+      def get_stat
+        ret = {}
+        ret['write-behind.path'] = File.expand_path(@path)
+        ret['write-behind.shift_size'] = @shift_size
+        ret['write-behind.do_write'] = @do_write
+        @fdh.each{|hname,fname|
+          ret["write-behind[#{hname}].path"] = File.expand_path(fname)
+          ret["write-behind[#{hname}].size"] = @total_size[hname]
+        }
+        ret
+      end
+
+      def write(hname, cmd, key, val)
+        @do_write = true
+        t = Time.now
+        if @total_size[hname] >= @shift_size || t >= @rottime
+          @do_write = false
+          rotate(hname)
+        end
+
+        fd = @fdh[hname]
+        unless fd
+          fd = openfile(hname)
+          @total_size[hname] = 0
+        end
+        klen = key.length
+        val = val.to_s
+        vlen = val.length
+        size = fd.write([t.to_i, cmd, klen, key, vlen, val].pack("NnNa#{klen}Na#{vlen}"))
+        @total_size[hname] += size
+#        @log.debug("WriteBehind:hname=#{hname} cmd=#{cmd} key=#{key} val=#{val} total_size=#{@total_size}")
+      ensure
+        @do_write = false
+      end
+
+      def rotate(hname)
+        @log.info("WriteBehind:rotate #{hname}")
+        fd_old = @fdh[hname]
+        unless fd_old
+          @log.info("WriteBehind:rotate #{hname} not opend")
+          return false
+        end
+        @fdh.delete(hname)
+        @fnh.delete(hname)
+        sleep 0.01 while @do_write
+        fd_old.close
+        @log.info("WriteBehind:rotate sccseed")
+        true
+      end
+
+      def openfile(hname)
+        t = Time.now
+        path = "#{@path}/#{@stats.ap_str}/#{hname}/#{t.strftime('%Y%m%d')}"
+        mkdir(path)
+        # set a next rotation time
+        @rottime = Time.local(t.year,t.month,t.day,0,0,0) + 24 * 60 * 60
+
+        max = -1
+        Dir::glob("#{path}/*.wb").each{|f|
+          if /\D(\d+).wb$/ =~ f
+            max = $1.to_i if $1.to_i > max
+          end
+        }
+        fname = "#{path}/#{max + 1}.wb"
+        fd = open(fname,'wb')
+        @fnh[hname] = fname
+        @fdh[hname] = fd
+      end
+
+      def wb_get_path(hname)
+        File.expand_path("#{@path}/#{@stats.ap_str}/#{hname}")
+      end
+
+      def get_current_file_path(hname)
+        @log.info("WriteBehind:get_current_file_path #{hname}")
+        unless @fnh[hname]
+          @log.info("WriteBehind:get_current_file_path #{hname} not opend")
+          return nil
+        end
+        File.expand_path("#{@fnh[hname]}")
+      end
+
+      def close_all
+        @fdh.each_value{|fd| fd.close }
+      end
+
+      def mkdir(path)
+        pbuf = ''
+        path.split('/').each{|p|
+          pbuf << p
+          begin
+            Dir::mkdir(pbuf) unless File.exist?(pbuf)
+          rescue
+          end
+          pbuf << '/'
+        }
+      end
+
+    end # class FileWriter
+    
+  end # module WriteBehind
+
+  module WriteBehindProcess
+
+    @@wb_queue = Queue.new
+
+    def self.push(hname, cmd, key, val)
+      @@wb_queue.push([hname, cmd, key, val])
+    end
+
+    def start_wb_process
+      @wb_thread = Thread.new{
+        wb_process_loop
+      }
+    rescue =>e
+      @log.error("#{e}\n#{$@}")
+    end
+
+    def stop_wb_process
+      until @@wb_queue.empty?
+        sleep 0.01
+      end
+      @wb_thread.exit
+      @wb_writer.close_all
+    end
+
+    def wb_rotate(hname)
+      @wb_writer.rotate(hname)
+    end
+
+    def wb_get_path(hname)
+      @wb_writer.wb_get_path(hname)
+    end
+
+    def wb_get_current_file_path(hname)
+      @wb_writer.get_current_file_path(hname)
+    end
+
+    def wb_get_stat
+      @wb_writer.get_stat
+    end
+
+    def wb_process_loop
+      loop {
+        while dat = @@wb_queue.pop
+          @wb_writer.write(dat[0], dat[1], dat[2], dat[3])
+        end
+      }
+    rescue =>e
+      @log.error("#{e}\n#{$@}")
+      retry
+    end
+    private :wb_process_loop
+
+  end # module WriteBehindProcess
+
+end # module Roma

data/test/rcirb.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require 'pp'
+require 'irb'
+
+path =  File.dirname(File.expand_path($PROGRAM_NAME))
+$LOAD_PATH << path + "/../lib"
+$LOAD_PATH << path  + "/../../commons/lib"
+$LOAD_PATH << path  + "/../../client/lib"
+
+require 'roma/client/rclient'
+
+$rc=Roma::Client::RomaClient.new(['roma0_11211'])
+
+IRB.start

data/test/roma-test-utils.rb

@@ -0,0 +1,65 @@
+require 'shell'
+
+require 'pathname'
+require 'fileutils'
+require 'rbconfig'
+
+module RomaTestUtils
+  module_function
+  def base_dir
+    Pathname(__FILE__).dirname.parent.parent.expand_path
+  end
+
+  def server_base_dir
+    base_dir + "server"
+  end
+
+  def server_bin_dir
+    server_base_dir + "bin"
+  end
+
+  def mkroute_path
+    (server_bin_dir + "mkroute").to_s
+  end
+
+  def romad_path
+    (server_bin_dir + "romad").to_s
+  end
+
+  def ruby_path
+    File.join(RbConfig::CONFIG["bindir"],
+              RbConfig::CONFIG["ruby_install_name"])
+  end
+
+  def start_roma
+    sh = Shell.new
+    sh.transact do
+      Dir.glob("localhost_1121?.*").each{|f| rm f }
+    end
+    FileUtils.rm_rf("localhost_11211")
+    FileUtils.rm_rf("localhost_11212")
+    sleep 0.1
+
+    sh.system(ruby_path, mkroute_path,
+              "localhost_11211","localhost_11212",
+              "-d","3",
+              "--enabled_repeathost")
+    sleep 0.1
+    sh.system(ruby_path,romad_path,"localhost","-p","11211","-d","--verbose")
+    sh.system(ruby_path,romad_path,"localhost","-p","11212","-d","--verbose")
+    sleep 0.5
+  end
+
+  def stop_roma
+    conn = Roma::Messaging::ConPool.instance.get_connection("localhost_11211")
+    if conn
+      conn.write "balse\r\n"
+      conn.gets
+      conn.write "yes\r\n"
+      conn.gets
+      conn.close
+    end
+  rescue =>e
+    puts "#{e} #{$@}"
+  end
+end

data/test/run-test.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'pathname'
+
+base_path = Pathname(__FILE__).dirname.parent.parent.expand_path
+$LOAD_PATH.unshift("#{base_path}/server/lib")
+$LOAD_PATH.unshift("#{base_path}/client/lib")
+$LOAD_PATH.unshift("#{base_path}/commons/lib")
+$LOAD_PATH.unshift("#{base_path}/server/test")
+
+require 'roma-test-utils'
+
+Dir["#{base_path}/server/test/t_*.rb"].each do |test_file|
+  require File.basename(test_file, '*.rb')
+end