roma-client 0.3.7

data/README

@@ -0,0 +1,17 @@
+================================================================
+ ROMA: A Distributed Key-Value Store in Ruby
+ Copyright (C) 2009 Rakuten, Inc. 
+================================================================
+
+ROMA is one of the data storing systems for distributed key-value
+stores. It is a completely decentralized distributed system that
+consists of multiple processes, called nodes, on several machines. It
+is based on pure P2P architecture like a distributed hash table, thus
+it provides high availability and scalability.
+
+ROMA is written in Ruby. However, following choices are available to
+access to ROMA.
+
+* Client libraries of Ruby and Java are available.
+* ROMA protocol is compatible with memcached text-based one so that 
+  any memcached client libraries allows users to interact with ROMA. 

data/Rakefile

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+require 'rubygems'
+require 'rake'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+
+RDOC_OPTIONS = [
+                '--line-numbers',
+                '--inline-source',
+                "--main", "README.rdoc",
+                "-c UTF-8",
+               ]
+
+# gem tasks
+PKG_FILES = FileList[
+  '[A-Z]*',
+  'bin/**/*',
+  'lib/**/*.rb',
+  'test/**/*.rb',
+  'spec/**/*.rb',
+  'doc/**/*',
+  'examples/**/*',
+]
+
+VER_NUM = `ruby -Ilib -e 'require "roma/client/version"; puts Roma::Client::VERSION::STRING'`
+
+if VER_NUM =~ /([0-9.]+)$/
+  CURRENT_VERSION = $1
+else
+  CURRENT_VERSION = "0.0.0"
+end
+
+SPEC = Gem::Specification.new do |s|
+  s.name = "roma-client"
+  s.version = CURRENT_VERSION
+  s.summary = "ROMA client library"
+  s.description = <<-EOF
+    ROMA client library
+  EOF
+  s.files = PKG_FILES.to_a
+
+  s.require_path = 'lib'                         # Use these for libraries.
+
+  s.has_rdoc = true
+  s.rdoc_options.concat RDOC_OPTIONS
+  s.extra_rdoc_files = ["README"]
+end
+
+package_task = Rake::GemPackageTask.new(SPEC) do |pkg|
+end
+
+
+Rake::RDocTask.new("doc") { |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title = "ROMA documents"
+  rdoc.options.concat RDOC_OPTIONS
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.include("README.rdoc")
+}

data/bin/rcdaemon

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+path =  File.dirname(File.expand_path($PROGRAM_NAME))
+$LOAD_PATH << path + "/../lib"
+
+require 'roma/client/proxy/daemon'

data/bin/sample

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+path =  File.dirname(File.expand_path($PROGRAM_NAME))
+$LOAD_PATH << path + "/../lib"
+
+if ARGV.length < 1
+  puts "usage:sample address:port"
+  exit
+end
+
+require 'roma/client'
+
+rc = Roma::Client::RomaClient.new(ARGV)
+
+n = 10
+
+n.times{|i|
+  rc["key-#{i}"]="value-#{i}"
+}
+
+n.times{|i|
+  puts rc["key-#{i}"]
+}

data/bin/showbalance

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+path =  File.dirname(File.expand_path($PROGRAM_NAME))
+$LOAD_PATH << path + "/../lib"
+
+require 'roma/client/tools/showbalance'

data/lib/roma/client/client_rttable.rb

@@ -0,0 +1,77 @@
+require 'yaml'
+require 'digest/sha1'
+require 'roma/client/routing/routing_data'
+
+module Roma
+  module Client
+
+    class ClientRoutingTable
+
+      attr :rd
+      attr :search_mask
+      attr :fail_cnt
+      attr :hbits
+      attr :rn
+      attr :div_bits
+      attr_accessor :mklhash
+
+      def initialize(rd)
+        @rd = rd
+        @rn = @rd.rn
+        @div_bits=@rd.div_bits
+        @hbits = 2**@rd.dgst_bits
+        @search_mask = @rd.search_mask
+        @fail_cnt = Hash.new(0)
+        @mklhash = nil
+      end
+
+      def nodes
+        @rd.nodes.clone
+      end
+
+      def vnodes
+        @rd.v_idx.keys
+      end
+
+      # Returns a vnode-id from digest.
+      def get_vnode_id(d)
+        d & @search_mask
+      end
+
+      # Returns a node-is list at the vnode. 
+      # +vn+: vnode-id
+      def search_nodes(vn)
+        @rd.v_idx[vn].clone
+      rescue
+        nil
+      end
+
+      def search_node(key)
+        d = Digest::SHA1.hexdigest(key).hex % @hbits
+        nodes = @rd.v_idx[d & @search_mask]
+        nodes.each_index { |i|
+          return [nodes[i], d] if @fail_cnt[nodes[i]] == 0
+        }
+        # for expecting an auto assign process
+        svn = vn = d & @search_mask
+        while( (vn = @rd.next_vnode(vn)) != svn )
+          nodes = @rd.v_idx[vn]
+          nodes.each_index { |i|
+            return [nodes[i], d] if @fail_cnt[nodes[i]] == 0
+          }
+        end
+        nil
+      rescue => e
+        p e
+        nil
+      end
+
+      def proc_failed(nid)
+        @fail_cnt[nid] += 1
+        @mklhash = 0
+      end
+
+    end # class ClientRoutingTable
+
+  end # module Client
+end # module Roma

data/lib/roma/client/con_pool.rb

@@ -0,0 +1,76 @@
+require 'thread'
+require 'socket'
+require 'singleton'
+
+module Roma
+  module Client
+    
+    class ConPool
+      include Singleton
+
+      attr_accessor :maxlength
+
+      def initialize(maxlength = 10)
+        @pool = {}
+        @maxlength = maxlength
+        @lock = Mutex.new
+      end
+
+      def get_connection(ap)
+        ret = @pool[ap].shift if @pool.key?(ap) && @pool[ap].length > 0
+        ret = create_connection(ap) unless ret
+        ret
+      rescue
+        nil
+      end
+
+      def return_connection(ap, con)
+        if @pool.key?(ap) && @pool[ap].length > 0
+          if @pool[ap].length > @maxlength
+            con.close
+          else
+            @pool[ap] << con
+          end
+        else
+          @pool[ap] = [con]
+        end
+      rescue
+      end
+
+      def create_connection(ap)
+        addr, port = ap.split(/[:_]/)
+        TCPSocket.new(addr, port)
+      end
+
+      def delete_connection(ap)
+        @pool.delete(ap)
+      end
+
+      def close_all
+        @pool.each_key{|ap| close_at(ap) }
+      end
+
+      def close_same_host(ap)
+        host,port = ap.split(/[:_]/)
+        @pool.each_key{|eap|
+          close_at(eap) if eap.split(/[:_]/)[0] == host
+        }
+      end
+      
+      def close_at(ap)
+        return unless @pool.key?(ap)
+        @lock.synchronize {
+          while(@pool[ap].length > 0)
+            begin
+              @pool[ap].shift.close
+            rescue =>e
+            end
+          end
+          @pool.delete(ap)
+        }
+      end
+
+    end # class ConPool
+
+  end # module Client
+end # module Roma

data/lib/roma/client/proxy/daemon.rb

@@ -0,0 +1,281 @@
+#!/usr/bin/env ruby
+#
+# client proxy daemon
+#
+require 'optparse'
+require 'eventmachine'
+require 'timeout'
+require 'singleton'
+require 'roma/client/sender'
+require 'roma/client/rlogger'
+require 'roma/client/client_rttable'
+
+module Roma
+  module Client
+    module Proxy
+
+      module RomaHandler
+        attr_accessor :ap
+        attr_reader :connected
+    
+        def post_init
+          $log.info("Connected to roma")
+          @connected = true
+        end
+
+        def unbind
+          $log.info("Disconnected from roma")
+          @connected = nil
+        end
+      end # module RomaHandler
+
+      module ClientHandler
+
+        def post_init
+          $log.info("Connected from client")
+          @cmd = ''
+        end
+
+        def receive_data(data)
+          @cmd << data
+          if @cmd.index("\n")
+            @roma_h = get_roma_handler(@cmd)
+            @roma_h.send_data(@cmd)
+            @cmd = ''
+            EM::enable_proxy(self, @roma_h)
+            EM::enable_proxy(@roma_h, self)
+          end
+        rescue =>e
+          $log.error("#{e} #{$@}")
+        end
+
+        def unbind
+          $log.info("Disconnected from client")
+          EM::disable_proxy(self)
+          if @roma_h
+            EM::disable_proxy(@roma_h)
+            Conpool::instance.return_connection(@roma_h)
+          end
+        rescue =>e
+          $log.error("#{e} #{$@}")
+        end
+
+        def get_roma_handler(cmd_line)
+          cmd, key_hname = cmd_line.split(' ')
+          key, hname = key_hname.split("\e")
+          nid, d = Daemon::rttable.search_node(key)
+          Conpool::instance.get_connection(nid, RomaHandler)
+        rescue =>e
+          $log.error("#{e} #{$@}")
+        end
+
+      end #  module ClientHandler
+
+      class Conpool
+        include Singleton
+
+        attr_accessor :maxlength
+
+        def initialize
+          @pool = {}
+          @maxlength = 10
+          @lock = Mutex.new
+        end
+
+        def get_connection(ap, handler)
+          ret = @pool[ap].shift if @pool.key?(ap) && @pool[ap].length > 0
+          ret = create_connection(ap, handler) if ret == nil
+          ret
+        end
+
+        def return_connection(con)
+          return unless con.connected
+          if @pool.key?(con.ap) && @pool[con.ap].length > 0
+            if @pool[con.ap].length > @maxlength
+              con.close_connection
+            else
+              @pool[con.ap] << con
+            end
+          else
+            @pool[con.ap] = [con]
+          end
+        end
+
+        def create_connection(ap, handler)
+          addr,port = ap.split('_')
+          con = EventMachine::connect(addr, port, handler)
+          con.ap = ap
+          con
+        end
+        
+        def close_all
+          @pool.each_key{|ap| close_at(ap) }
+        end
+
+        def close_at(ap)
+          return unless @pool.key?(ap)
+          @lock.synchronize {
+            while(@pool[ap].length > 0)
+              begin
+                @pool[ap].shift.close_connection
+              rescue =>e
+                $log.error("#{e} #{$@}")
+              end
+            end
+            @pool.delete(ap)
+          }
+        end
+      end # class Conpool
+
+      class Daemon
+        attr_reader :daemon
+
+        @@rttable = nil
+
+        def self.rttable
+          @@rttable
+        end
+
+        def initialize(argv = nil)
+          options(argv)
+          initialize_logger
+          @sender = Roma::Client::Sender.new
+          update_rttable(@init_nodes)
+        end
+
+        def initialize_logger
+          Roma::Logging::RLogger.create_singleton_instance(@log_path,
+                                                           @log_age,
+                                                           @log_size)
+        end
+
+        def start
+          
+          timer
+          
+          loop do
+            begin
+              EventMachine::run do
+                EventMachine.start_server('0.0.0.0', @port, ClientHandler)
+                EventMachine.start_unix_domain_server("/tmp/#{@uds_name}", ClientHandler)
+              end
+            rescue =>e
+              $log.error("#{e} #{$@}")
+              retry
+            end
+          end
+        end
+
+        private
+
+        def update_rttable(nodes)
+          raise RuntimeError.new("nodes must not be nil.") unless nodes
+          
+          nodes.each { |node|
+            rt = make_rttable(node)
+            if rt != nil
+              @@rttable = rt
+              return
+            end
+          }
+          raise RuntimeError.new("fatal error")
+        end
+
+        def make_rttable(node)
+          mklhash = @sender.send_route_mklhash_command(node)
+          return nil unless mklhash
+
+          if @@rttable && @@rttable.mklhash == mklhash
+            return @@rttable
+          end
+
+          rd = @sender.send_routedump_command(node)
+          if rd
+            ret = Roma::Client::ClientRoutingTable.new(rd)
+            ret.mklhash = mklhash
+            return ret
+          end
+          nil
+        rescue =>e
+          $log.error("#{e} #{$@}")
+          nil
+        end
+
+        def options(argv)
+          opts = OptionParser.new
+          opts.banner="usage:#{File.basename($0)} [options] addr_port"
+
+          @uds_name = 'roma'
+          opts.on("-n", "--name [name]","Unix domain socket name.default=roma") { |v| @uds_name = v }
+          @port = 12345
+          opts.on("-p", "--port [port number]","default=12345"){ |v| @port = v.to_i }
+          @log_path = "./rcdaemon.log"
+          opts.on("-l", "--log [path]","default=./"){ |v|
+            @log_path = v
+            @log_path << "/" if @log_path[-1] != "/"
+            @log_path << "rcdaemon.log"
+          }
+
+          @daemon = true
+          opts.on(nil, "--debug"){ @daemon = false }
+          @log_age = 10
+          @log_size = 1024 * 1024
+
+          opts.parse!(argv)
+          raise OptionParser::ParseError.new if argv.length < 1
+          @init_nodes = argv
+        rescue OptionParser::ParseError => e
+          $stderr.puts e.message
+          $stderr.puts opts.help
+          exit 1
+        end
+
+        def timer
+          Thread.new do
+            loop do
+              sleep 10
+              timer_event_10sec
+            end
+          end
+        end
+
+        def timer_event_10sec
+          update_rttable(@@rttable.nodes)
+        end
+
+        def self.daemon
+          p = Process.fork {
+            pid=Process.setsid
+            Signal.trap(:INT){
+              exit! 0
+            }
+            Signal.trap(:TERM){
+              exit! 0       
+            }
+            Signal.trap(:HUP){
+              exit! 0
+            }
+            File.open("/dev/null","r+"){|f|
+              STDIN.reopen f
+              STDOUT.reopen f
+              STDERR.reopen f
+            }
+            yield
+          }
+          $stderr.puts p
+          exit! 0
+        end
+
+      end # class Daemon
+
+    end # module Proxy
+  end # module Client
+end # module Roma
+
+d = Roma::Client::Proxy::Daemon.new(ARGV)
+$log = Roma::Logging::RLogger.instance
+if d.daemon
+  Roma::Client::Proxy::Daemon.daemon{ d.start }
+else
+  d.start
+end