kyototycoon 0.1.0

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.1.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.1"
+  gem "rcov", ">= 0"
+  gem "msgpack", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,30 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.5.1)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    msgpack (0.4.4)
+    rake (0.8.7)
+    rcov (0.9.9)
+    rspec (2.1.0)
+      rspec-core (~> 2.1.0)
+      rspec-expectations (~> 2.1.0)
+      rspec-mocks (~> 2.1.0)
+    rspec-core (2.1.0)
+    rspec-expectations (2.1.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.1)
+  msgpack
+  rcov
+  rspec (~> 2.1.0)

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2010 uu59<a@tt25.org>
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,95 @@
+# Install
+
+    $ gem install kyototycoon
+
+# Example
+
+## Simple case
+
+    @kt = KyotoTycoon.new
+
+    # traditional style
+    @kt.set('foo', 123)
+    p @kt.get('foo') # => "123".  carefully, it is String, not Integer, by default
+
+    # Ruby's hash style
+    @kt['bar'] = 42
+    p @kt['bar'] # => "42".
+    @kt[:baz] = :aaa # => key/value are automatically #to_s
+
+    @kt.delete(:foo)
+
+
+## Complex case
+
+    @kt = KyotoTycoon.new('remotehost', 12345) # connect any host, any port
+    @kt.db = '*' # on memory, or DB file as KT known
+
+    # set/bulk_set/get/bulk_get uses msgpack. default as :default
+    @kt.serializer = :msgpack
+
+    # KT library logging
+    logger = Logger.new(STDERR)
+    logger.level = Logger::WARN
+    @kt.logger = logger
+    # or you can use these:
+    # @kt.logger = 'ktlib.log'
+    # @kt.logger = STDOUT
+    # @kt.logger = Logger.new(STDOUT)
+
+    # HTTP agent
+    @kt.agent = :skinny # low-level socket communicate. a bit of faster than :nethttp(default). try benchmark/agent.rb
+
+    # standby server
+    @kt.connect_timeout = 0.5 # => wait 0.5 sec for connection open
+    @kt.servers << ['server2', 1978] # standby server that will use when primary server (a.k.a. KT#new(host, port)) is dead.
+    @kt.servers << ['server3', 1978] # same as above
+
+    # get/set
+    @kt.set('foo', 42, 100) # => expire at 100 seconds after
+    @kt['foo'] # => 42. it is interger by msgpack serializer works
+
+    # delete all record
+    @kt.clear
+
+    # bulk set/get
+    @kt.set_bulk({
+      'foo' => 'foo',
+      'bar' => 'bar',
+    })
+    @kt.get_bulk([:foo, 'bar']) # => {'_foo' => 'foo', '_bar' => 'bar', 'num' => '2'}
+    @kt.remove_bulk([:foo, :bar])
+
+    # it can store when msgpack using.
+    @kt['baz'] = {'a' => 'a', 'b' => 'b}
+    @kt['baz'] # => {'a' => 'a', 'b' => 'b}
+
+    # increment
+    @kt.increment('bar') # => 1
+    @kt.increment('bar') # => 2
+    @kt.increment('bar', 10) # => 12
+    @kt.increment('bar', -5) # => 7
+
+    # delete keys
+    @kt.delete(:foo, :bar, :baz)
+
+    # prefix keys
+    @kt.match_prefix('fo') # => all start with 'fo' keys
+    @kt.match_regex('^fo') # => save as above
+    @kt.match_regex(/^fo/) # => save as above
+
+    # reporting / statistics
+    p @kt.report
+    p @kt.status
+    all_record_count = @kt.status['count']
+
+# Requirements
+
+- msgpack(optional)
+
+# Trap
+
+KyotoTycoon is based on HTTP so all variable types are become String.
+It means `(@kt["counter"] ||= 1) < 10` does not work by default.
+
+Using :msgpack serializer for avoid this trap.

data/Rakefile

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "kyototycoon"
+  gem.homepage = "http://github.com/uu59/kyototycoon-ruby"
+  gem.license = "MIT"
+  gem.summary = %Q{KyotoTycoon client for Ruby}
+  gem.description = %Q{KyotoTycoon client for Ruby}
+  gem.email = "a@tt25.org"
+  gem.authors = ["uu59"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/*.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "test #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/benchmark/agent.rb

@@ -0,0 +1,27 @@
+# -- coding: utf-8
+
+require "rubygems"
+require "benchmark"
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'kyototycoon.rb'
+
+kt = KyotoTycoon.new
+job = lambda {|kt|
+  10000.times{|n|
+    kt.set(n.to_s, n)
+    kt.get(n)
+  }
+  kt.clear
+}
+Benchmark.bm do |x|
+  x.report('skinny') {
+    kt.agent = :skinny
+    kt.serializer=:default
+    job.call(kt)
+  }
+  x.report('nethttp') {
+    kt.agent = :nethttp
+    kt.serializer=:default
+    job.call(kt)
+  }
+end

data/benchmark/bulk.rb

@@ -0,0 +1,37 @@
+# -- coding: utf-8
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require "rubygems"
+require "benchmark"
+require 'kyototycoon.rb'
+
+kt = KyotoTycoon.new
+bulk={}
+50000.times.map{|n|
+  bulk[n.to_s] = "#{n}-#{rand}"
+}
+job = lambda {|kt|
+  kt.set_bulk(bulk)
+  kt.get_bulk(bulk.keys)
+  kt.clear
+}
+Benchmark.bm do |x|
+  x.report('default') {
+    kt.serializer=:default
+    job.call(kt)
+  }
+  x.report('msgpack') {
+    kt.serializer=:msgpack
+    job.call(kt)
+  }
+  x.report('default(skinny)') {
+    kt.agent = :skinny
+    kt.serializer=:default
+    job.call(kt)
+  }
+  x.report('msgpack(skinny)') {
+    kt.agent = :skinny
+    kt.serializer=:msgpack
+    job.call(kt)
+  }
+end

data/benchmark/bulk_bigdata.rb

@@ -0,0 +1,28 @@
+# -- coding: utf-8
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require "rubygems"
+require "benchmark"
+require 'kyototycoon.rb'
+
+kt = KyotoTycoon.new
+bulk={}
+str = "string ああ" * 10000
+100.times.map{|n|
+  bulk[n.to_s] = str
+}
+job = lambda {|kt|
+  kt.set_bulk(bulk)
+  kt.get_bulk(bulk.keys)
+  kt.clear
+}
+Benchmark.bm do |x|
+  x.report('default') {
+    kt.serializer=:default
+    job.call(kt)
+  }
+  x.report('msgpack') {
+    kt.serializer=:msgpack
+    job.call(kt)
+  }
+end

data/benchmark/getset.rb

@@ -0,0 +1,37 @@
+# -- coding: utf-8
+
+require "rubygems"
+require "benchmark"
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'kyoto_tycoon.rb'
+
+kt = KyotoTycoon.new
+job = lambda {|kt|
+  1000.times{|n|
+    kt.set(n.to_s, n)
+    kt.get(n)
+  }
+  kt.clear
+}
+Benchmark.bm do |x|
+  x.report('default') {
+    kt.agent = :nethttp
+    kt.serializer=:default
+    job.call(kt)
+  }
+  x.report('msgpack') {
+    kt.agent = :nethttp
+    kt.serializer=:msgpack
+    job.call(kt)
+  }
+  x.report('default(skinny)') {
+    kt.agent = :skinny
+    kt.serializer=:default
+    job.call(kt)
+  }
+  x.report('msgpack(skinny)') {
+    kt.agent = :skinny
+    kt.serializer=:msgpack
+    job.call(kt)
+  }
+end

data/benchmark/getset_while_1sec.rb

@@ -0,0 +1,33 @@
+# -- coding: utf-8
+
+require "rubygems"
+require "benchmark"
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require "msgpack"
+require 'kyototycoon.rb'
+
+job = lambda {|kt|
+  cnt = 0
+  begin
+    timeout(1){
+      loop do
+        kt[:foo] = :bar
+        kt[:foo]
+        cnt += 1
+      end
+    }
+  rescue Timeout::Error
+  end
+  kt.clear
+  cnt
+}
+
+kt = KyotoTycoon.new
+
+%w"nethttp skinny".each{|agent|
+  %w!default msgpack!.each{|serializer|
+    kt.agent = agent.to_sym
+    kt.serializer = serializer.to_sym
+    puts "#{agent}/#{serializer}: #{job.call(kt)}"
+  }
+}

data/kyototycoon.gemspec

@@ -0,0 +1,74 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{kyototycoon}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["uu59"]
+  s.date = %q{2010-12-09}
+  s.description = %q{KyotoTycoon client for Ruby}
+  s.email = %q{a@tt25.org}
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    "Gemfile",
+    "Gemfile.lock",
+    "MIT-LICENSE",
+    "README.markdown",
+    "Rakefile",
+    "VERSION",
+    "benchmark/agent.rb",
+    "benchmark/bulk.rb",
+    "benchmark/bulk_bigdata.rb",
+    "benchmark/getset.rb",
+    "benchmark/getset_while_1sec.rb",
+    "kyototycoon.gemspec",
+    "lib/kyototycoon.rb",
+    "lib/kyototycoon/serializer.rb",
+    "lib/kyototycoon/serializer/default.rb",
+    "lib/kyototycoon/serializer/msgpack.rb",
+    "lib/kyototycoon/tsvrpc.rb",
+    "lib/kyototycoon/tsvrpc/nethttp.rb",
+    "lib/kyototycoon/tsvrpc/skinny.rb",
+    "spec/helper.rb"
+  ]
+  s.homepage = %q{http://github.com/uu59/kyototycoon-ruby}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{KyotoTycoon client for Ruby}
+  s.test_files = [
+    "spec/helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, ["~> 2.1.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.1"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+      s.add_development_dependency(%q<msgpack>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, ["~> 2.1.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.1"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+      s.add_dependency(%q<msgpack>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, ["~> 2.1.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.1"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+    s.add_dependency(%q<msgpack>, [">= 0"])
+  end
+end
+

data/lib/kyototycoon/serializer/default.rb

@@ -0,0 +1,15 @@
+# -- coding: utf-8
+
+class KyotoTycoon
+  module Serializer
+    class Default
+      def self.encode(obj)
+        obj
+      end
+
+      def self.decode(str)
+        str
+      end
+    end
+  end
+end

data/lib/kyototycoon/serializer/msgpack.rb

@@ -0,0 +1,18 @@
+# -- coding: utf-8
+
+require "rubygems"
+require "msgpack"
+
+class KyotoTycoon
+  module Serializer
+    class Msgpack
+      def self.encode(obj)
+        obj.to_msgpack
+      end
+
+      def self.decode(str)
+        MessagePack.unpack(str) if str
+      end
+    end
+  end
+end

data/lib/kyototycoon/serializer.rb

@@ -0,0 +1,13 @@
+# -- coding: utf-8
+
+class KyotoTycoon
+  module Serializer
+    def self.get(adaptor)
+      dir = "#{File.dirname(__FILE__)}/serializer"
+      if File.exists?(File.join(dir, "#{adaptor}.rb"))
+        require "#{dir}/#{adaptor}.rb"
+      end
+      const_get(adaptor.to_s.capitalize)
+    end
+  end
+end

data/lib/kyototycoon/tsvrpc/nethttp.rb

@@ -0,0 +1,28 @@
+# -- coding: utf-8
+
+require "rubygems"
+
+class KyotoTycoon
+  class Tsvrpc
+    class Nethttp
+      def initialize(host, port)
+        @host = host
+        @port = port
+        @http ||= ::Net::HTTP.new(@host, @port)
+      end
+
+      def request(path, params, colenc)
+        query = KyotoTycoon::Tsvrpc.build_query(params, colenc)
+        req = Net::HTTP::Post.new(path)
+        if query.length > 0
+          req.body = query
+          req['Content-Length'] = query.size
+        end
+        req['Content-Type'] = "text/tab-separated-values; colenc=#{colenc}"
+        req['Connection'] = "close"
+        res = @http.request(req)
+        [res.code.to_i, res.body]
+      end
+    end
+  end
+end

data/lib/kyototycoon/tsvrpc/skinny.rb

@@ -0,0 +1,40 @@
+# -- coding: utf-8
+
+class KyotoTycoon
+  class Tsvrpc
+    class Skinny
+      def initialize(host, port)
+        @host = host
+        @port = port
+        @tpl = ""
+        @tpl << "POST %s HTTP/1.0\r\n"
+        @tpl << "Content-Length: %d\r\n"
+        @tpl << "Content-Type: text/tab-separated-values; colenc=%s\r\n"
+        @tpl << "\r\n%s"
+      end
+
+      def request(path, params, colenc)
+        sock ||= ::TCPSocket.new(@host, @port)
+        query = KyotoTycoon::Tsvrpc.build_query(params, colenc)
+        request = @tpl % [path, query.bytesize, colenc, query]
+        sock.write(request)
+        status = sock.gets[9, 3]
+        bodylen = 0
+        body = ""
+        loop do
+          line = sock.gets
+          if line['Content-Length']
+            bodylen = line.match(/[0-9]+/)[0].to_i
+            next
+          end
+          if line == "\r\n"
+            break
+          end
+        end
+        body = sock.read(bodylen)
+        sock.close
+        [status.to_i, body]
+      end
+    end
+  end
+end

data/lib/kyototycoon/tsvrpc.rb

@@ -0,0 +1,55 @@
+# -- coding: utf-8
+
+
+class KyotoTycoon
+  class Tsvrpc
+    def initialize(host, port)
+      @host = host
+      @port = port
+    end
+
+    def http(agent)
+      case agent
+        when :skinny
+          Skinny.new(@host, @port)
+        else
+          Nethttp.new(@host, @port)
+      end
+    end
+
+    def request(path, params, agent, colenc)
+      status,body = *http(agent).request(path, params, colenc)
+      if ![200, 450].include?(status)
+        raise body
+      end
+      {:status => status, :body => body}
+    end
+
+    def self.parse(body)
+      body.split("\n").inject({}){|r, line|
+        k,v = *line.split("\t", 2).map{|v| CGI.unescape(v)}
+        r[k] = v
+        r
+      }
+    end
+
+    def self.build_query(params, colenc='U')
+      query = ""
+      if params
+        case colenc.to_s.upcase.to_sym
+          when :U
+            query = params.inject([]){|r, tmp|
+              r << tmp.map{|v| CGI.escape(v.to_s)}.join("\t")
+            }.join("\r\n")
+          when :B
+            query = params.inject([]){|r, tmp|
+              r << tmp.map{|v| Base64.encode64(v.to_s).rstrip}.join("\t")
+            }.join("\r\n")
+          else
+            raise "Unknown colenc '#{colenc}'"
+        end
+      end
+      query
+    end
+  end
+end

data/lib/kyototycoon.rb

@@ -0,0 +1,232 @@
+# -- coding: utf-8
+
+require "logger"
+require "cgi"
+require "socket"
+require "base64"
+require "net/http"
+require "kyototycoon/serializer.rb"
+require "kyototycoon/serializer/default.rb"
+require "kyototycoon/tsvrpc.rb"
+require "kyototycoon/tsvrpc/skinny.rb"
+require "kyototycoon/tsvrpc/nethttp.rb"
+
+class KyotoTycoon
+  attr_accessor :colenc, :connect_timeout, :servers
+
+  def initialize(host='0.0.0.0', port=1978)
+    @servers = [[host, port]]
+    @serializer = KyotoTycoon::Serializer::Default
+    @logger = Logger.new(nil)
+    @agent = :nethttp
+    @colenc = :U
+    @connect_timeout = 0.5
+  end
+
+  def serializer= (adaptor=:default)
+    klass = KyotoTycoon::Serializer.get(adaptor)
+    @serializer = klass
+  end
+
+  def db= (db)
+    @db = db
+  end
+
+  def logger= (logger)
+    if logger.class != Logger
+      logger = Logger.new(logger)
+    end
+    @logger = logger
+  end
+
+  def agent=(agent)
+    @agent = agent
+  end
+
+  def get(key)
+    res = request('/rpc/get', {:key => key})
+    @serializer.decode(Tsvrpc.parse(res[:body])['value'])
+  end
+  alias_method :[], :get
+
+  def remove(*keys)
+    remove_bulk(keys.flatten)
+  end
+  alias_method :delete, :remove
+
+  def set(key, value, xt=nil)
+    res = request('/rpc/set', {:key => key, :value => @serializer.encode(value), :xt => xt})
+    Tsvrpc.parse(res[:body])
+  end
+  alias_method :[]=, :set
+
+  def add(key, value, xt=nil)
+    res = request('/rpc/add', {:key => key, :value => @serializer.encode(value), :xt => xt})
+    Tsvrpc.parse(res[:body])
+  end
+
+  def replace(key, value, xt=nil)
+    res = request('/rpc/replace', {:key => key, :value => @serializer.encode(value), :xt => xt})
+    Tsvrpc.parse(res[:body])
+  end
+
+  def append(key, value, xt=nil)
+    request('/rpc/append', {:key => key, :value => @serializer.encode(value), :xt => xt})
+  end
+
+  def cas(key, oldval, newval, xt=nil)
+    res = request('/rpc/cas', {:key => key, :oval=> @serializer.encode(oldval), :nval => @serializer.encode(newval), :xt => xt})
+    case res[:status].to_i
+      when 200
+        true
+      when 450
+        false
+    end
+  end
+
+  def increment(key, num=1, xt=nil)
+    res = request('/rpc/increment', {:key => key, :num => num, :xt => xt})
+    Tsvrpc.parse(res[:body])['num'].to_i
+  end
+
+  def increment_double(key, num, xt=nil)
+    res = request('/rpc/increment_double', {:key => key, :num => num, :xt => xt})
+    Tsvrpc.parse(res[:body])['num'].to_f
+  end
+
+  def set_bulk(records)
+    # records={'a' => 'aa', 'b' => 'bb'}
+    values = {}
+    records.each{|k,v|
+      values["_#{k}"] = @serializer.encode(v)
+    }
+    res = request('/rpc/set_bulk', values)
+    Tsvrpc.parse(res[:body])
+  end
+
+  def get_bulk(keys)
+    params = keys.inject({}){|params, k|
+      params[k.to_s.match(/^_/) ? k.to_s : "_#{k}"] = ''
+      params
+    }
+    res = request('/rpc/get_bulk', params)
+    ret = {}
+    Tsvrpc.parse(res[:body]).each{|k,v|
+      ret[k] = k.match(/^_/) ? @serializer.decode(v) : v
+    }
+    ret
+  end
+
+  def remove_bulk(keys)
+    params = keys.inject({}){|params, k|
+      params[k.to_s.match(/^_/) ? k.to_s : "_#{k}"] = ''
+      params
+    }
+    res = request('/rpc/remove_bulk', params)
+    Tsvrpc.parse(res[:body])
+  end
+
+  def clear
+    request('/rpc/clear')
+  end
+
+  def vacuum
+    request('/rpc/vacuum')
+  end
+
+  def sync(params={})
+    request('/rpc/synchronize', params)
+  end
+  alias_method :syncronize, :sync
+
+  def echo(value)
+    res = request('/rpc/echo', value)
+    Tsvrpc.parse(res[:body])
+  end
+
+  def report
+    res = request('/rpc/report')
+    Tsvrpc.parse(res[:body])
+  end
+
+  def status
+    res = request('/rpc/status')
+    Tsvrpc.parse(res[:body])
+  end
+
+  def match_prefix(prefix)
+    res = request('/rpc/match_prefix', {:prefix => prefix})
+    keys = []
+    Tsvrpc.parse(res[:body]).each{|k,v|
+      if k != 'num'
+        keys << k[1, k.length]
+      end
+    }
+    keys
+  end
+
+  def match_regex(re)
+    if re.class == Regexp
+      re = re.source
+    end
+    res = request('/rpc/match_regex', {:regex => re})
+    keys = []
+    Tsvrpc.parse(res[:body]).each{|k,v|
+      if k != 'num'
+        keys << k[1, k.length]
+      end
+    }
+    keys
+  end
+
+  def keys
+    match_prefix("")
+  end
+
+  def request(path, params=nil)
+    if @db
+      params ||= {}
+      params[:DB] = @db
+    end
+    if @servers.length > 1
+      @servers.each{|s|
+        host,port = *s
+        if ping(host, port)
+          @servers = [[host, port]]
+          break
+        end
+      }
+    end
+    if @servers.length == 0
+      msg = "alived server not exists"
+      @logger.crit(msg)
+      raise msg
+    end
+    @tsvrpc ||= begin
+      host, port = *@servers.first
+      Tsvrpc.new(host, port)
+    end
+    res = @tsvrpc.request(path, params, @agent, @colenc)
+    @logger.info("#{path}: #{res[:code]} with query parameters #{params.inspect}")
+    res
+  end
+
+  def ping(host, port)
+    begin
+      timeout(@connect_timeout){
+        @logger.debug("connect check #{host}:#{port}")
+        rpc = Tsvrpc.new(host, port)
+        res = rpc.request('/rpc/echo', {'0' => '0'}, :skinny, :U)
+        @logger.debug(res)
+      }
+      true
+    rescue Timeout::Error => ex
+      # Ruby 1.8.7 compatible
+      @logger.warn("connect failed at #{host}:#{port}")
+      false
+    rescue => ex
+      @logger.warn("connect failed at #{host}:#{port}")
+      false
+    end
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,122 @@
+# -- coding: utf-8
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + "/../lib")
+require "rubygems"
+require "kyototycoon.rb"
+
+describe do
+  before(:all) do
+    @kt = KyotoTycoon.new
+    @kt.serializer=:default # or :msgpack
+    @kt.db='*' # in memory
+    @kt.logger=nil
+  end
+
+  before(:each) do
+    @kt.clear
+  end
+
+  it 'should handle multi servers' do
+    kt = KyotoTycoon.new('www.example.com', 11111)
+    kt.connect_timeout = 0.1
+    kt.servers << ['example.net', 1978]
+    kt.servers << ['0.0.0.0', 1978]
+    kt['foo'] = 'bar'
+    kt[:foo].should == 'bar'
+  end
+
+  it 'should provide simple kvs feature' do
+    @kt.set('a', 'b')
+    @kt.get('a').should == 'b'
+    @kt['foo'] = 'bar'
+    @kt['foo'].should == 'bar'
+    @kt.delete('foo')
+    @kt['foo'].should be_nil
+    @kt.clear
+    @kt.report['db_total_count'].to_i.should == 0
+    @kt.status['count'].to_i.should == 0
+
+    @kt['foo'] = 'oldbaz'
+    @kt.cas('foo', 'oldbaz', 'newbaz').should be_true
+    @kt.cas('foo', 'oldbaz', 'newbaz').should be_false
+    @kt.get('foo').should == 'newbaz'
+    @kt.clear
+
+    @kt['foo'] ||= 'aaa'
+    @kt['foo'] ||= 'bbb'
+    @kt['foo'].should == 'aaa'
+    @kt.clear
+
+    @kt[:a] = 1
+    @kt[:b] = 1
+    @kt.keys.sort.should == %w!a b!.sort
+  end
+
+  it 'should provide bulk' do
+    data = {}
+    receive = {}
+    10.times{|n|
+      data[n.to_s] = n.to_s
+      receive["_#{n}"] = n.to_s
+    }
+    receive['num'] = "10"
+    @kt.set_bulk(data)
+    @kt.get_bulk(data.keys).sort.should == receive.sort
+    @kt.remove_bulk(data.keys)
+    @kt.get_bulk(data.keys).should == {'num' => '0'}
+  end
+
+  it 'should can handle strange key/value' do
+    # '+' is known ambiguity key on URL encode/decode processing
+    %w!a\tb a\nb a\r\nb a*-b a^@b!.each{|outlaw|
+      @kt[outlaw] = outlaw
+      @kt[outlaw].should == outlaw
+    }
+  end
+
+  it 'should provide delete variation' do
+    build = lambda {|kt|
+      kt.clear
+      kt.set_bulk({
+        :a => 1,
+        :b => 1,
+        :c => 1,
+      })
+    }
+    build.call(@kt)
+    @kt.delete('a','b')
+    @kt.keys.should == ['c']
+
+    build.call(@kt)
+    @kt.delete(['a', 'b'])
+    @kt.keys.should == ['c']
+  end
+
+  it 'should increment' do
+    @kt.increment('foo').should == 1
+    @kt.increment('foo').should == 2
+    @kt.increment('foo').should == 3
+    @kt.increment('foo', 10).should == 13
+    @kt.increment('foo', -10).should == 3
+  end
+
+  it 'should provide status/report' do
+    @kt[:a] = 1
+    @kt[:b] = 2
+    @kt.report['db_total_count'].to_i.should == 2
+    @kt.status['count'].to_i.should == 2
+  end
+
+  it 'should match prefixes' do
+    @kt['123'] = 1
+    @kt['124'] = 1
+    @kt['125'] = 1
+    @kt['999'] = 1
+    @kt['9999'] = 1
+    @kt.match_prefix("12").sort.should == %w!123 124 125!.sort
+    @kt.match_prefix("9").sort.should == %w!999 9999!.sort
+    @kt.match_prefix("9999").sort.should == %w!9999!
+    @kt.match_regex(/^12/).sort.should == %w!123 124 125!.sort
+    @kt.match_regex(/^9+$/).sort.should == %w!999 9999!.sort
+  end
+end

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification 
+name: kyototycoon
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- uu59
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-09 00:00:00 +09:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 1
+        - 0
+        version: 2.1.0
+  type: :development
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 5
+        - 1
+        version: 1.5.1
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: msgpack
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+description: KyotoTycoon client for Ruby
+email: a@tt25.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- benchmark/agent.rb
+- benchmark/bulk.rb
+- benchmark/bulk_bigdata.rb
+- benchmark/getset.rb
+- benchmark/getset_while_1sec.rb
+- kyototycoon.gemspec
+- lib/kyototycoon.rb
+- lib/kyototycoon/serializer.rb
+- lib/kyototycoon/serializer/default.rb
+- lib/kyototycoon/serializer/msgpack.rb
+- lib/kyototycoon/tsvrpc.rb
+- lib/kyototycoon/tsvrpc/nethttp.rb
+- lib/kyototycoon/tsvrpc/skinny.rb
+- spec/helper.rb
+has_rdoc: true
+homepage: http://github.com/uu59/kyototycoon-ruby
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 999236175897460152
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: KyotoTycoon client for Ruby
+test_files: 
+- spec/helper.rb