kyototycoon-client 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in kyototycoon-client.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 imasho
+
+MIT License
+
+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.md

@@ -0,0 +1,72 @@
+# Kyototycoon::Client
+
+KyotoTycoon ruby client with TCP connection and binary protocol.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'kyototycoon-client'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install kyototycoon-client
+
+## Usage
+
+### Create instance
+
+    require "kyototycoon/client"
+    
+    client = Kyototycoon::Client.new(host, port)
+    client.open
+    
+    # kyototycoon operations here
+    
+    client.close
+
+### get/ret/remove operations
+
+Simple case:  
+
+    > client.set("key", "value")  # set single key-value
+    => true
+    > client.set_bulk({"key1" => "value1", "key2" => "value2"})  # set multiple key-value
+    => 2  # number of success key-value set
+    > client.get("key")  # get single key 
+    => "value" # return value or nil
+    > client.get_bulk(["key1", "key2"]) # set multiple keys
+    => {"key1" => "value1", "key2" => "value2"}  # return key-value map
+
+Key expiration:  
+
+    > client.set("key", "value", 3600) # third parameter is seconds for key expiration
+    => true
+    > client.set_bulk({"key1" => ["value1", 3600], "key2" => "value2"})  # key1 will expire after 3600 seconds, key2 never expire
+    => 2
+
+Remove key:  
+
+    > client.remove("key")  # remove signle key
+    => true
+    > client.remove_bulk(["key1", "key2"]) # remove multiple keys 
+    => 2   # number of keys removed
+
+### Play LUA script
+
+KyotoTyccon supports server-side LUA scripting extention.
+
+Client can call LUA method with method name and key-value set arguments.
+
+Client receives response as key-value set format.
+
+    > client.script("key", "value")  # single key-value argument
+    => {"keyA" => "valueA", "keyB" => "valueB", ...}  # receive key-value set
+    > client.script({"key1" => "value1", "key2" => "value2"})  # multiple key-value argument
+    => {"keyX" => "valueX", "keyY" => "valueY", ... } 
+
+Number of key sent and number of key received are depend on LUA function definition.

data/Rakefile

@@ -0,0 +1,33 @@
+require 'bundler/gem_helper'
+require 'rake/testtask'
+
+Bundler::GemHelper.new(Dir.pwd).instance_eval do
+  desc "Build #{name}-#{version}.gem into the pkg directory"
+  task 'build' do
+    build_gem
+  end
+
+  desc "Build and install #{name}-#{version}.gem into system gems"
+  task 'install' do
+    install_gem
+  end
+
+  desc "benchmark module"
+  task 'benchmark' do
+    raise "host and port reauired: rake benchmark HOST=[HOST] PORT=[PORT]" if !ENV["HOST"] || !ENV["PORT"]
+
+    if ENV["COUNT"].to_i > 0
+      system "ruby test/benchmark.rb #{ENV["HOST"]} #{ENV["PORT"]} #{ENV["COUNT"]}"
+    else
+      system "ruby test/benchmark.rb #{ENV["HOST"]} #{ENV["PORT"]}"
+    end
+  end
+end
+
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+end
+
+task :default => :test

data/kyototycoon-client.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'kyototycoon/client/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "kyototycoon-client"
+  spec.version       = Kyototycoon::Client::VERSION
+  spec.authors       = ["imasho"]
+  spec.email         = ["imasho@gmail.com"]
+  spec.description   = %q{KyotoTycoon binary access module, supports get(bulk), set(bulk), remove(bulk), and play LUA script.}
+  spec.summary       = %q{KyotoTycoon binary access module}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/kyototycoon/client.rb

@@ -0,0 +1,89 @@
+require "kyototycoon/client/version"
+require "kyototycoon/client/record"
+require "kyototycoon/client/connection"
+
+module Kyototycoon
+  class Client
+    attr_reader :host, :port, :timeout_ms, :connection
+
+    def initialize(host, port, timeout_ms = 0)
+      @host = host
+      @port = port
+      @timeout_ms = timeout_ms
+      @connection = Connection.new(@host, @port, @timeout_ms)
+    end
+
+    def open
+      @connection.open
+    end
+
+    def close
+      raise "connection doesn't open" unless @connection && @connection.is_open
+      @connection.close
+    end
+
+    def set(key, value, expire=Record::MAX_EXPIRE_SECONDS, dbid=0)
+      set_bulk({key => [value, expire]}, dbid) == 1 ? true : false
+    end
+
+    def get(key, dbid=0)
+      get_bulk([key], dbid)[key]
+    end
+
+    def remove(key)
+      remove_bulk([key]) == 1 ? true : false
+    end
+
+    def script(method, key, value)
+      script_bulk(method, { key => value } ) 
+    end
+
+    def set_bulk(keyvalues, dbid = 0)
+      raise "connection closed" unless @connection.is_open
+
+      records = []
+      keyvalues.each do |k, v|
+        if v.is_a?(Array)
+          records.push(Record.new(k, v[0], v[1].to_i, dbid))
+        else
+          records.push(Record.new(k, v, Record::MAX_EXPIRE_SECONDS, dbid))
+        end
+      end
+      @connection.set(records)
+    end
+
+    def get_bulk(keys, dbid=0)
+      raise "connection closed" unless @connection.is_open
+
+      records = []
+      keys.each do |k|
+        records.push(Record.new(k, nil, nil, dbid))
+      end
+      results = @connection.get(records)
+      return {} if results == nil
+      results.inject({}) {|map, rec| map[rec.key] = rec.value; map;}
+    end
+
+    def remove_bulk(keys)
+      raise "connection closed" unless @connection.is_open
+
+      records = []
+      keys.each do |k|
+        records.push(Record.new(k, nil))
+      end 
+      @connection.remove(records)
+    end
+
+    def script_bulk(method, keyvalues)
+      raise "connection closed" unless @connection.is_open
+
+      records = []
+      keyvalues.each do |k, v|
+        records.push(Record.new(k, v))
+      end
+      results = @connection.script(records)
+      return {} if results == nil
+      results.inject({}) {|map, rec| map[rec.key] = rec.value; map;}
+    end
+  end
+end

data/lib/kyototycoon/client/connection.rb

@@ -0,0 +1,124 @@
+require "socket"
+require "kyototycoon/client/magic"
+require "kyototycoon/client/flag"
+
+module Kyototycoon
+  class Connection
+    attr_reader :host, :port, :timeout_ms, :socket, :is_open
+
+    def initialize(host, port, timeout_ms)
+      @host = host
+      @port = port
+      @timeout_ms = timeout_ms
+      @is_open = false
+    end
+
+    def open
+      return if @is_open
+      @socket = TCPSocket.open(host, port)
+      @is_open = true
+    end
+
+    def close
+      return unless @is_open
+      @socket.close
+      @is_open = false
+    end
+
+    def set(records)
+      header_entries = [Magic::SET_BULK, Flag::RESERVED, records.length]
+      request = header_entries.pack("CNN")
+
+      records.each do |r|
+        request << [r.db_id, r.key.length, r.value.length, r.expire.to_i >> 32, r.expire.to_i & 0x00000000FFFFFFFF].pack("nNNNN")  <<
+                    r.key << r.value
+      end
+
+      @socket.write(request)
+      response = @socket.read(5) 
+      raise "no response" unless response
+
+      magic, count = response.unpack("CN")
+      raise "invalid protocol header" unless magic == Magic::SET_BULK
+
+      count.to_i # number of registerd
+    end
+
+    def get(records)
+      header_entries = [Magic::GET_BULK, Flag::RESERVED, records.length]
+      request = header_entries.pack("CNN")
+
+      records.each do |r|
+        request << [r.db_id, r.key.length].pack("nN") << r.key
+      end
+
+      @socket.write(request)
+      res_header = @socket.read(5)
+      raise "no response" unless res_header
+
+      magic, count = res_header.unpack("CN")
+      raise "invalid protocol header" unless magic == Magic::GET_BULK
+
+      results = []
+      count.times do |i|
+        res_body = @socket.read(18)
+
+        dbid, keysize, valuesize, ext_expire, expire = res_body.unpack("nNNNN")
+        expire = ext_expire << 32 | expire
+
+        key = @socket.read(keysize)
+        value = @socket.read(valuesize)
+        results.push(Record.new(key, value, dbid, expire))
+      end
+
+      results
+    end
+
+    def remove(records)
+      header_entries = [Magic::REMOVE_BULK, Flag::RESERVED, records.length]
+      request = header_entries.pack("CNN")
+
+      records.each do |r|
+        request <<  [r.db_id, r.key.length].pack("nN") << r.key
+      end
+    
+      @socket.write(request)
+      response = @socket.read(5) 
+      raise "no response" unless response
+
+      magic, count = response.unpack("CN")
+      raise "invalid protocol header" unless magic == Magic::REMOVE_BULK
+
+      count.to_i # number of registerd
+    end
+
+    def script(records)
+      header_entries = [Magic::PLAY_SCRIPT, Flag::RESERVED, records.length]
+      request = header_entries.pack("CNN")
+
+      records.each do |r|
+        request << [r.key.length, r.value.length].pack("NN") << r.key << r.value
+      end
+
+      @socket.write(request)
+      res_header = @socket.read(5)
+      raise "no response" unless res_header
+
+      magic, count = res_header.unpack("CN")
+      raise "invalid protocol header" unless magic == Magic::PLAY_SCRIPT
+
+      results = []
+      count.times do |i|
+        res_body = @socket.read(8)
+        keysize, valuesize = res_body.unpack("NN")
+        key = @socket.read(keysize)
+        value = @socket.read(valuesize)
+        results.push(Record.new(key, value, 0, 0))
+      end
+
+      results
+    end
+  end
+end
+
+

data/lib/kyototycoon/client/flag.rb

@@ -0,0 +1,5 @@
+module Kyototycoon
+  module Flag
+    RESERVED = 0
+  end
+end

data/lib/kyototycoon/client/magic.rb

@@ -0,0 +1,8 @@
+module Kyototycoon
+  module Magic
+    SET_BULK    = 0xB8
+    REMOVE_BULK = 0xB9
+    GET_BULK    = 0xBA
+    PLAY_SCRIPT = 0xB4
+  end
+end

data/lib/kyototycoon/client/record.rb

@@ -0,0 +1,14 @@
+module Kyototycoon
+  class Record
+    MAX_EXPIRE_SECONDS = 0x7FFFFFFFFFFFFFFF
+
+    attr_accessor :key, :value, :db_id, :expire
+
+    def initialize(key, value, expire=MAX_EXPIRE_SECONDS, db_id=0)
+      @key    = key
+      @value  = value
+      @expire = expire
+      @db_id  = db_id
+    end
+  end
+end

data/lib/kyototycoon/client/version.rb

@@ -0,0 +1,5 @@
+module Kyototycoon
+  class Client
+    VERSION = "0.0.1"
+  end
+end

data/test/benchmark.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/ruby
+
+require "rubygems"
+require "kyototycoon/client"
+require "benchmark"
+
+if ARGV.length != 2 && ARGV.length != 3
+  print "usage: ruby benchmark.rb [HOST] [PORT]\n"
+  exit 1
+end
+
+client = Kyototycoon::Client.new(ARGV[0], ARGV[1])
+client.open
+bench_count = (ARGV[2] || 100000).to_i
+
+records = {}
+bench_count.times do |i|
+  records["testdata#{i}"] = "value#{i}"
+end
+
+Benchmark.bm do |b|
+  b.report("set_bulk: ") {
+    client.set_bulk(records)
+  }
+
+  b.report("set     : ") {
+    bench_count.times do |i|
+      client.set("iteration#{i}", "value#{i}")
+    end
+  }
+
+  b.report("get_bulk: ") {
+    result = client.get_bulk(records.keys)
+    raise unless result.size == bench_count
+  }
+  
+  b.report("get     : ") {
+    bench_count.times do |i|
+      v = client.get("iteration#{i}")
+      raise unless v == "value#{i}"
+    end
+  }
+
+end
+
+client.close
+exit 0

data/test/helper.rb

@@ -0,0 +1,16 @@
+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 'test/unit'
+require "kyototycoon/client"
+
+class Test::Unit::TestCase
+end

data/test/kyototycoon/client/test_client.rb

@@ -0,0 +1,72 @@
+require "helper"
+
+class ClientTest < Test::Unit::TestCase
+  def setup
+    raise "host and port of KyotoTycoon test server is required: rake test HOST=xxx PORT=xxx" if (!ENV["HOST"] || !ENV["PORT"])
+    @client = Kyototycoon::Client.new(ENV["HOST"], ENV["PORT"].to_i) 
+  end
+
+  def test_open
+    @client.open
+    @client.close
+  end
+
+
+  def test_clud
+    @client.open
+    assert_equal(@client.set("key1", "value1"), true)
+    assert_equal(@client.get("key1"), "value1")
+    assert_nil(@client.get("key999"))
+    assert_equal(@client.remove("key1"), true)
+    assert_nil(@client.get("key1"))
+    @client.close
+  end
+
+  def test_clud_bulk
+    @client.open
+    assert_equal( @client.set_bulk( {"key1" => "valueA", "key2" => "valueB", "key3" => "valueC"} ), 3)
+    assert_equal( @client.get_bulk( ["key1", "key2", "key3", "key4"] ), 
+                                    {"key1" => "valueA", "key2" => "valueB", "key3" => "valueC"} )
+    assert_equal( @client.remove_bulk( ["key1", "key2"] ), 2 )
+    assert_equal( @client.get_bulk( ["key1", "key2", "key3", "key4"] ), 
+                                    {"key3" => "valueC"} )
+    @client.close
+  end
+
+  def test_expire
+    @client.open
+    assert_equal(@client.set_bulk( {"key1" => ["value1", 1]} ), 1)   # expire after 1 second
+    assert_equal(@client.set_bulk( {"key2" => "value2"} ), 1)        # not expire
+    assert_equal(@client.set("key3", "value3"), true)                # not expire
+    assert_equal(@client.set("key4", "value4", 1), true)             # expire after 1 second
+
+    assert_equal(@client.get("key1"), "value1")
+    assert_equal(@client.get("key2"), "value2")
+    assert_equal(@client.get("key3"), "value3")
+    assert_equal(@client.get("key4"), "value4")
+    sleep 3
+    assert_equal(@client.get("key1"), nil)
+    assert_equal(@client.get("key2"), "value2")
+    assert_equal(@client.get("key3"), "value3")
+    assert_equal(@client.get("key4"), nil)
+    @client.close
+  end
+
+  def test_dbid
+    @client.open
+    assert_equal(@client.set_bulk( {"key1" => "value1"}, 0 ), 1)
+    assert_equal(@client.set_bulk( {"key1" => "value1"}, 1 ), 0)
+    assert_equal(@client.get("key1", 0), "value1")
+    assert_equal(@client.get("key1", 1), nil)
+    @client.close
+  end
+
+  # def test_script
+  #   return unless @client
+
+  #  @client.open
+  #  assert_equal( @client.script("dummy", "key", "value"), {} )
+  #  assert_equal( @client.script_bulk("dummy", {}), {} )
+  #  @client.close
+  # end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: kyototycoon-client
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- imasho
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: KyotoTycoon binary access module, supports get(bulk), set(bulk), remove(bulk),
+  and play LUA script.
+email:
+- imasho@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- kyototycoon-client.gemspec
+- lib/kyototycoon/client.rb
+- lib/kyototycoon/client/connection.rb
+- lib/kyototycoon/client/flag.rb
+- lib/kyototycoon/client/magic.rb
+- lib/kyototycoon/client/record.rb
+- lib/kyototycoon/client/version.rb
+- test/benchmark.rb
+- test/helper.rb
+- test/kyototycoon/client/test_client.rb
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: KyotoTycoon binary access module
+test_files:
+- test/benchmark.rb
+- test/helper.rb
+- test/kyototycoon/client/test_client.rb