em-tycoon 0.9.0

data/.gitignore

@@ -0,0 +1 @@
+html

data/.rvmrc

@@ -0,0 +1 @@
+rvm ruby-1.9.2

data/Gemfile

@@ -0,0 +1,9 @@
+source :gemcutter
+
+group(:test) do
+	gem 'rspec'
+	gem 'mocha'
+	gem 'em-spec', :git => 'git://github.com/bcg/em-spec.git'
+	gem 'child-process-manager'
+end
+gemspec

data/Gemfile.lock

@@ -0,0 +1,37 @@
+GIT
+  remote: git://github.com/bcg/em-spec.git
+  revision: e44d67847794d317078cf357271863447d26c8c5
+  specs:
+    em-spec (0.2.2)
+
+PATH
+  remote: .
+  specs:
+    em-tycoon (0.0.1)
+      eventmachine
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    child-process-manager (0.0.3)
+    diff-lcs (1.1.2)
+    eventmachine (0.12.10)
+    mocha (0.9.12)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.2)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  child-process-manager
+  em-spec!
+  em-tycoon!
+  mocha
+  rspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2011 Chris Ingrassia
+
+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.rdoc

@@ -0,0 +1,38 @@
+= em_tycoon
+
+An async client for Kyoto Tycoon (http://fallabs.com/kyototycoon/) using EventMachine
+
+== Overview
+
+em_tycoon uses Kyoto Tycoon's binary protocol (see http://fallabs.com/kyototycoon/spex.html#protocol) for increased efficiency, it does not currently implement any of the commands available outside of that protocol.  This means you are currently limited to:
+
+* get_bulk
+* set_bulk
+* remove_bulk
+* play_script
+
+== Quick start
+
+	require 'em-tycoon'
+	
+	EM.run do
+		tycoon = EM::Tycoon.connect(:host => 'localhost', :port => 1978)
+		# The second key will expire after 24 hours
+		tycoon.set("key1" => "value1", "key_with_xt" => {:value => "value2", :xt => (Time.now+86400)}) do |set_result| 
+			unless set_result.nil?
+				puts "Set #{set_result} keys"
+				tycoon.get("key1","key_with_xt") do |get_result|
+					get_result.each_pair do |key,value|
+						puts "Got #{key} = #{value[:value]} with expiration time : #{value[:xt] || 'None'}"
+					end
+				end
+			else
+				puts "Error!"
+			end
+		end
+	end
+
+== Copyright
+
+Copyright (c) 2011 Chris Ingrassia. See LICENSE for details.
+

data/Rakefile

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.setup
+
+require 'rspec'
+require 'rspec/core/rake_task'
+
+desc 'Build .gem from Gemspec'
+task :build do
+  system('gem build em-tycoon.gemspec')
+end
+
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = "-c"
+  t.pattern = FileList['spec/*_spec.rb']
+end
+
+namespace :spec do
+  desc "Spawns (and then reaps) a ktserver process to run online tests against "
+  RSpec::Core::RakeTask.new(:online) do |t|
+    t.rspec_opts = "-c"
+    t.pattern = FileList['spec/online/**/*_spec.rb']
+  end
+end
+
+require 'rake/rdoctask'
+
+desc 'Generates RDOC'
+Rake::RDocTask.new do |rd|
+  rd.main = 'README.rdoc'
+  rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+
+  rd.options += [
+    '-SHN',
+    '-f', 'darkfish',  # This is the important bit
+  ]
+end
+
+desc "Shells out to 'bundle install'"
+task :bundle do
+   system('bundle install > /dev/null')
+end
+

data/em-tycoon.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "em-tycoon"
+  s.version     = "0.9.0"
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Chris Ingrassia"]
+  s.email       = ["chris@noneofyo.biz"]
+  s.homepage    = "http://github.com/andry1/em-tycoon"
+  s.summary     = %q{EventMachine client for Kyoto Tycoon}
+  s.description = %q{An async client for Kyoto Tycoon's binary protocol using EventMachine}
+
+  s.rubyforge_project = "em-tycoon"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency(%q<eventmachine>, [">= 0"])
+end

data/lib/em-tycoon.rb

@@ -0,0 +1,6 @@
+require 'eventmachine'
+require_relative 'em/tycoon'
+require_relative 'em/tycoon/protocol/message'
+['error', 'get','set','remove', 'play_script'].each do |x|
+  require_relative "em/tycoon/protocol/binary/#{x}_message"
+end

data/lib/em/tycoon.rb

@@ -0,0 +1,134 @@
+require 'eventmachine'
+require_relative 'tycoon/protocol/parser'
+
+module EM
+  # EventMachine Kyoto Tycoon Driver
+  # Uses Kyoto Tycoon's binary protocol for increased efficiency (see "Binary Protocol" at http://fallabs.com/kyototycoon/spex.html#protocol)
+  # To get started:
+  #
+  #   tycoon = EM::Tycoon.connect(:host => 'localhost', :port => 1978)
+  #   tycoon.get("key1","key2","key3") do |results|
+  #     results.each_pair { |k,v| puts "#{k} = #{v[:value]}" }
+  #   end
+  #
+  module Tycoon
+    DEFAULT_OPTS = {:host => '127.0.0.1', :port => 1978}
+    REQUEST_TIMEOUT = 2 # Timeout requests after 2 seconds
+  
+    # Connect to a Kyoto Tycoon host, supported options are:
+    # * :host => host name or IP address of ktserver instance (default '127.0.0.1')
+    # * :port => port ktserver is listening on (default 1978)
+    def self.connect(options={})
+      options = DEFAULT_OPTS.merge(options)
+      EM.connect(options[:host], options[:port], Client)
+    end
+  
+    # Kyoto Tycoon binary protocol handler
+    class Client < EM::Connection
+      
+      def initialize
+        super
+      end
+      
+      def post_init
+        @jobs = []
+      end
+    
+      def receive_data(data)
+        bytes_parsed = 0
+        while @jobs.any? && (bytes_parsed < data.bytesize)
+          bytes_parsed += @jobs.first.parse_chunk(data[bytes_parsed..-1])
+          @jobs.shift if @jobs.first.message.parsed?
+        end
+      end
+      
+      def unbind
+      end
+      
+      # Use KT binary protocol "set_bulk" command to set keys and values passed in the data argument,
+      # with the option to pass an optional expiration time by specifying it in the value, in the following format:
+      #
+      # {
+      #    "my_key1"          => "my value for my_key1",
+      #    "my_key2"          => "my value for my_key2",
+      #    "my_key3_with_60s_xt"  => {:value => "my value for my_key3_with_60s_xt", :xt => 60}
+      # }
+      #
+      # Expiration times can be specified either as an integer representing the number of seconds the key should persist
+      # after it is created, or as a Time object containing the absolute time at which the key should expire.
+      #
+      # On completion, the callback block will be called (if provided) with the number of records stored as returned
+      # by Kyoto Tycoon, or nil on error.  If no callback is specified, the no-reply option will be passed to Kyoto Tycoon.
+      # 
+      def set(data={},&cb)
+        msg = Protocol::Message.generate(:set, data, {:no_reply => !(block_given?)})
+        if block_given?
+          job = Protocol::Parser.new(REQUEST_TIMEOUT)
+          job.callback { |result|
+            cb.call(result) if block_given?
+          }
+          job.errback { |result|
+            cb.call(nil) if block_given?
+          }
+          @jobs << job
+          send_data(msg)
+        end
+      end
+      
+      # Use KT binary protocol "get_bulk" command to get values for the given keys
+      # The callback will be called upon completion and passed a hash with the returned values and expirations
+      # (see EM::Tycoon::Client#set), or nil on error
+      def get(*keys,&cb)
+        raise ArgumentError.new("No block given") unless block_given?
+        msg = Protocol::Message.generate(:get, keys)
+        job = Protocol::Parser.new(REQUEST_TIMEOUT)
+        job.callback { |result|
+          cb.call(result) if block_given?
+        }
+        job.errback { |result|
+          cb.call(nil) if block_given?
+        }
+        @jobs << job
+        send_data(msg)
+      end
+      
+      # Use KT binary protocol "remove_bulk" command to remove the given keys
+      # The callback will be called upon completion and passed the number of keys deleted, or nil on error
+      def remove(keys=[],&cb)
+        msg = Protocol::Message.generate(:remove, keys)
+        if block_given?
+          job = Protocol::Parser.new(REQUEST_TIMEOUT)
+          job.callback { |result|
+            cb.call(result) if block_given?
+          }
+          job.errback { |result|
+            cb.call(nil) if block_given?
+          }
+          @jobs << job
+          send_data(msg)
+        end
+      end
+      
+      # Use KT binary protocol "play_script" command to execute the script function passed in the script_name
+      # argument, with the arguments passed in args
+      # The callback will be called upon completion and passed a hash containing the key/value pairs returned
+      # by the script (see EM::Tycoon::Client#set), or nil on error
+      def play_script(script_name, args={}, &cb)
+        msg = Protocol::Message.generate(:play_script, [script_name,args])
+        if block_given?
+          job = Protocol::Parser.new(REQUEST_TIMEOUT)
+          job.callback { |result|
+            cb.call(result) if block_given?
+          }
+          job.errback { |result|
+            cb.call(nil) if block_given?
+          }
+          @jobs << job
+          send_data(msg)
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/em/tycoon/protocol/binary/error_message.rb

@@ -0,0 +1,18 @@
+module EM
+  module Tycoon
+    module Protocol  
+      module Binary
+        class ErrorMessage < EM::Tycoon::Protocol::Message
+          def initialize(data={},opts={})
+            super(:error)
+            @bytes_expected = 1
+          end
+          
+          def self.from_bytes(data=nil)
+            return self.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/em/tycoon/protocol/binary/get_message.rb

@@ -0,0 +1,91 @@
+module EM
+  module Tycoon
+    module Protocol  
+      module Binary
+        class GetMessage < EM::Tycoon::Protocol::Message
+          HEADER_BYTES_PER_RECORD = (
+            2 + # (uint16_t): (iteration): the index of the target database.
+            4 + # (uint32_t): (iteration): the size of the key.
+            4 + # (uint32_t): (iteration): the size of the value.
+            8   # (int64_t): (iteration): the expiration time.
+          )
+          PARSE_PHASES=EM::Tycoon::Protocol::Message::PARSE_PHASES+[:header,:keys_and_values]
+          HEADER_UNPACK_FORMAT="nNNH16"
+          # Best I can figure it, Mikio is passing in 63 bits of 1s in set_bulk messages inside
+          # his own utilities to force KT to detect an overflow of the _real_ max XT time (which is 40 bits of 1s)
+          # and then returns that real max XT time in the get_bulk reply... I think
+          NO_EXPIRATION_TIME_RESPONSE=0x000000ffffffffff
+          def initialize(data={},opts={})
+            super(:get,data)
+            @key_fmt = String.new
+            @value_fmt = String.new
+            @xts = Array.new
+            @db_idxs = Array.new
+            @keys_parsed = 0
+            @keysize = 0
+            @valuesize = 0
+            @dbidx = 0
+            @xt = 0
+          end
+          
+          def self.generate(data,opts={})
+            data = [data.to_s] unless data.kind_of?(Array)
+            msg_array = [MAGIC[:get], 0, data.length]
+            data.each {|k|
+              msg_array += [0, k.bytesize, k]
+            }
+            return msg_array.pack("CNN#{'nNa*'*data.length}")
+          end
+
+          def parse_chunk(data)
+            return 0 unless data && data.bytesize > 0
+            msg_hsh = {}
+            bytes_parsed = 0
+            case parse_phase
+            when :magic,:item_count
+              @magic, @item_count = data.unpack("CN")
+              @parse_phase = :header
+              @bytes_expected += HEADER_BYTES_PER_RECORD
+              bytes_parsed = 5
+              @data = Hash.new
+            when :header
+              @dbidx,@keysize,@valuesize,@xt = data.unpack(HEADER_UNPACK_FORMAT)
+              @xt = @xt.to_i(16)
+              @bytes_expected += (@keysize+@valuesize)
+              bytes_parsed = HEADER_BYTES_PER_RECORD
+              @parse_phase = :keys_and_values
+            when :keys_and_values
+              k,v = data.unpack("a#{@keysize}a#{@valuesize}")
+              @data[k] = {
+                :value => v,
+                :dbidx => @dbidx,
+                :xt => (@xt == NO_EXPIRATION_TIME_RESPONSE) ? nil : Time.at(@xt)
+              }
+              bytes_parsed = (@keysize+@valuesize)
+              @keysize = 0
+              @valuesize = 0
+              @dbidx = 0
+              @xt = nil
+              if (@keys_parsed+=1) == item_count
+                @parse_phase = :done
+              else
+                @parse_phase = :header
+                @bytes_expected += HEADER_BYTES_PER_RECORD
+              end
+            end
+            return bytes_parsed
+          end
+          
+          def keysize
+            @key_sizes.inject {|sum,x| sum += x}
+          end
+          
+          def valuesize
+            @value_sizes.inject {|sum,x| sum += x}
+          end
+          
+        end
+      end
+    end
+  end
+end

data/lib/em/tycoon/protocol/binary/play_script_message.rb

@@ -0,0 +1,76 @@
+module EM
+  module Tycoon
+    module Protocol
+      module Binary
+        class PlayScriptMessage < EM::Tycoon::Protocol::Message
+          KV_PACK_FMT="NNa*a*"
+          HEADER_BYTES_PER_RECORD=8
+          
+          def initialize(data={},opts={})
+            super(:play_script,data)
+            @keys_parsed = 0
+            @keysize = 0
+            @valuesize = 0
+          end
+          
+          def self.generate(data,opts={})
+            raise ArgumentError.new("Unsupported data type : #{data.class.name}") unless data.kind_of?(Array)
+            raise ArgumentError.new("Expected array of [<String>,<Hash>]") unless (data.length == 2) && data.first.kind_of?(String) && data.last.kind_of?(Hash)
+            script_name = data.first
+            args = data.last
+            msg_array = [MAGIC[:play_script]]
+            optflags = 0
+            opts.each_pair do |optkey,optval|
+               optflags |= FLAGS[optkey] if (FLAGS.has_key?(optkey) and (optval == true))
+            end
+            msg_array << optflags
+            msg_array << script_name.bytesize
+            msg_array << args.keys.length
+            msg_array << script_name
+            args.each_pair do |key,value|
+              value = value
+              msg_array << key.bytesize
+              msg_array << value.bytesize
+              msg_array << key.to_s
+              msg_array << value.to_s
+            end
+            return msg_array.pack("CNNNa*#{KV_PACK_FMT*args.keys.length}")
+           end
+           
+           def parse_chunk(data)
+              return 0 unless data && data.bytesize > 0
+              msg_hsh = {}
+              bytes_parsed = 0
+              case parse_phase
+              when :magic,:item_count
+                @magic, @item_count = data.unpack("CN")
+                @parse_phase = :header
+                @bytes_expected += HEADER_BYTES_PER_RECORD
+                bytes_parsed = 5
+                @data = Hash.new
+              when :header
+                @keysize,@valuesize = data.unpack("NN")
+                @bytes_expected += (@keysize+@valuesize)
+                bytes_parsed = HEADER_BYTES_PER_RECORD
+                @parse_phase = :keys_and_values
+              when :keys_and_values
+                k,v = data.unpack("a#{@keysize}a#{@valuesize}")
+                @data[k] = {:value => v}
+                bytes_parsed = (@keysize+@valuesize)
+                @keysize = 0
+                @valuesize = 0
+                if (@keys_parsed+=1) == item_count
+                  @parse_phase = :done
+                else
+                  @parse_phase = :header
+                  @bytes_expected += HEADER_BYTES_PER_RECORD
+                end
+              end
+              return bytes_parsed
+            end
+           
+        end
+      end
+    end
+  end
+end

data/lib/em/tycoon/protocol/binary/remove_message.rb

@@ -0,0 +1,31 @@
+module EM
+  module Tycoon
+    module Protocol  
+      module Binary
+        class RemoveMessage < EM::Tycoon::Protocol::Message
+
+          def initialize(data=nil,opts={})
+            super(:remove,data)
+          end
+          
+          def self.generate(data,opts={})
+            data = [data.to_s] unless data.kind_of?(Array)
+            msg_array = [MAGIC[:remove]]
+            optflags = 0
+            opts.each_pair do |optkey,optval|
+               optflags |= FLAGS[optkey] if (FLAGS.has_key?(optkey) and (optval == true))
+            end
+            msg_array << optflags
+            msg_array << data.length
+            data.each do |d|
+              msg_array << 0 # dbidx
+              msg_array << d.to_s.bytesize
+              msg_array << d
+            end
+            return msg_array.pack("CNN#{'nNa*'*data.length}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/em/tycoon/protocol/binary/set_message.rb

@@ -0,0 +1,42 @@
+module EM
+  module Tycoon
+    module Protocol
+      module Binary
+        class SetMessage < EM::Tycoon::Protocol::Message
+
+          def initialize(data={},opts={})
+            super(:set,data)
+          end
+          
+          def self.generate(data,opts={})
+            raise ArgumentError.new("Unsupported data type : #{data.class.name}") unless data.kind_of?(Hash)
+            msg_array = [MAGIC[:set]]
+            optflags = 0
+            opts.each_pair do |optkey,optval|
+               optflags |= FLAGS[optkey] if (FLAGS.has_key?(optkey) and (optval == true))
+            end
+            msg_array << optflags
+            msg_array << data.keys.length
+            data.each_pair do |key,value|
+              xt = NO_XT_HEX
+              if value.kind_of?(Hash)
+                if value.has_key?(:xt)
+                  xt = ("%016X" % (value[:xt].kind_of?(Time) ? (value[:xt] - Time.now).to_i : value[:xt].to_i))
+                end
+                value = value[:value]
+              end
+              msg_array << 0 # dbidx
+              msg_array << key.bytesize
+              msg_array << value.bytesize
+              msg_array << xt
+              msg_array << key
+              msg_array << value
+            end
+            return msg_array.pack("CNN#{KV_PACK_FMT*data.keys.length}")
+           end
+           
+        end 
+      end     
+    end
+  end
+end

data/lib/em/tycoon/protocol/message.rb

@@ -0,0 +1,142 @@
+module EM
+  module Tycoon
+    module Protocol
+      
+      # Represents a Kyoto Tycoon binary protocol message
+      # See KT docs : http://fallabs.com/kyototycoon/spex.html#protocol
+      class Message
+        MAGIC={:set => 0xB8,
+               :get => 0xBA,
+               :remove => 0xB9,
+               :play_script => 0xB4,
+               :replication => 0xB1,
+               :error => 0xBF}
+        MSG_TYPES=MAGIC.invert
+        FLAGS = {:no_reply => 0x01}
+        DEFAULT_OPTS = {
+          :no_reply => false
+        }
+        NO_EXPIRATION_TIME = 0x7FFFFFFFFFFFFFFF
+        PARSE_PHASES=[:magic,:item_count]
+        NO_XT_HEX="7#{'F'*15}"
+        KV_PACK_FMT="nNNH*a*a*"
+  
+        attr_reader :bytes_expected,:parsed,:buffer,:parse_phase
+        # The human-readable symbol version of the KT message type, as defined in the keys of Message::MAGIC
+        attr_accessor :type
+        # "Magic" number header from KT message, indicating message type
+        attr_reader :magic
+        # Number of items/KV pairs contained in KT message
+        attr_reader :item_count
+        # Total size, in bytes, of all key data contained in KT message
+        attr_reader :keysize
+        # Total size, in bytes, of all value data contained in KT message
+        attr_reader :valuesize
+        # The data payload of the KT message, which can either be empty, contain a hash of KV pairs, or
+        # a list of keys
+        attr_reader :data
+        
+        # Create a new KT message object to parse a response from KT or to serialize one to send,
+        # type indicates the message type being created, as defined by the keys of Message::MAGIC
+        # (e.g. :set, :get, etc.), and the optional data parameter can be used to specify the initial
+        # contents of the message, specific to the message type
+        def initialize(type,data=nil)
+          self.class.check_msg_type(type)
+          self.type = type
+          @data = data
+          @bytes_per_record = 0
+          @bytes_expected = 5
+          @keysize = @valuesize = 0
+          @parsed = false
+          @buffer = String.new
+          @parse_phase = PARSE_PHASES.first
+        end
+        
+        def type=(t)
+          self.class.check_msg_type(t)
+          @type = t.downcase.to_sym
+          @magic = MAGIC[@type]
+          return @type
+        end
+        
+        # Parse an arbitrary blob of data, possibly containing an entire message, possibly part of it, possibly more than 1
+        # returns the number of bytes from the buffer that were actually parsed and updates the #bytes_expected
+        # property accordingly
+        def parse(data)
+          return 0 unless data && data.bytesize > 0
+          if data.bytesize < @bytes_expected
+            @buffer << data
+            @bytes_expected -= data.bytesize
+            return data.bytesize
+          else
+            @buffer << data[0..@bytes_expected]
+            bytes_parsed = parse_chunk(@buffer)
+            return 0 if bytes_parsed == 0 # This is an error
+            @bytes_expected -= bytes_parsed
+            @buffer = String.new
+            if @bytes_expected == 0
+              @parsed = true
+            elsif (data.bytesize-bytes_parsed) > 0
+              bytes_parsed += parse(data[bytes_parsed..-1])
+            end
+            return bytes_parsed 
+          end
+        end
+        
+        # Parse a Kyoto Tycoon binary protocol message part into this Message instance, returning the number
+        # of bytes parsed.  Default implementation supports standard magic+hits or just magic (in case of error message)
+        # messages     
+        def parse_chunk(data)
+          return 0 if data.nil?
+          return 0 unless data.bytesize == @bytes_expected
+          bytes_parsed = 0
+          if @bytes_expected > 1
+            @magic,@item_count = data.unpack("CN")
+            bytes_parsed = 5
+          else
+            @magic = data.unpack("C").first
+            bytes_parsed = 1
+          end
+          @data = @item_count
+          @parse_phase = :item_count
+          return bytes_parsed
+        end
+              
+        def parsed?
+          @parsed
+        end
+        
+        def [](key)
+          @data[key]
+        end
+        
+        class << self
+          protected(:new)
+          
+          def message_for(data)
+            msgtype = msg_type_for(data)
+            raise ArgumentError.new("Unknown magic byte 0x#{('%02X' % data[0])}") unless msgtype
+            classname = msgtype.to_s.gsub(/^[a-z]|_[a-z]/) {|c| c.upcase}.gsub('_','') + "Message"
+            Binary.const_get(classname).new(data)
+          end
+          
+          def msg_type_for(data)
+            magic = data.unpack("C").first
+            MSG_TYPES[magic]
+          end
+          
+          def generate(type, data, opts={})
+            check_msg_type(type)
+            opts=DEFAULT_OPTS.merge(opts)
+            classname = type.to_s.gsub(/^[a-z]|_[a-z]/) {|c| c.upcase}.gsub('_','') + "Message"
+            Binary.const_get(classname).generate(data,opts)
+          end
+        
+          def check_msg_type(type)
+            raise ArgumentError.new("Unknown message type #{type.inspect}") unless MAGIC.has_key?(type.downcase.to_sym)
+          end          
+        end
+      end
+    end
+  end
+end

data/lib/em/tycoon/protocol/parser.rb

@@ -0,0 +1,29 @@
+require 'eventmachine'
+
+module EM
+  module Tycoon
+    module Protocol
+      class Parser
+        include EM::Deferrable
+        attr_reader :result,:bytes_parsed,:message
+        attr_accessor :buffer
+        
+        # Create a new Parser deferrable, using the specified initial data and optional timeout specified in seconds
+        def initialize(timeout=0)
+          @bytes_parsed = 0
+          timeout(timeout) if timeout > 0
+          @message = nil
+        end
+        
+        def parse_chunk(data)
+          @message ||= Message.message_for(data)
+          @bytes_parsed += @message.parse(data)
+          @result = @message.data
+          succeed(@message.data) if @message.parsed?
+          return @bytes_parsed
+        end
+        
+      end
+    end
+  end
+end

data/spec/kt_msg_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper.rb'
+
+describe "Kyoto Tycoon Messages" do
+  before(:each) do
+    @single_set_hsh = {
+      "mykey" => "myvalue"
+    }
+    @multiple_set_hsh = {
+      "mykey1" => "myvalue1",
+      "my_longer_key2" => "myvalue2",
+      "mykey3" => "my_longer_value3"
+    }
+    @get_key = @single_set_hsh.keys.first
+    @multiple_get_keys = @multiple_set_hsh.keys
+    @single_set_keysize = @single_set_hsh.keys.first.bytesize
+    @single_set_valuesize = @single_set_hsh.values.first.bytesize
+    @multiple_set_packed = [0xB8, 0, 3]
+    @play_script_packed = [0xB4, 0, "myscript".bytesize, @multiple_set_hsh.keys.length, "myscript"]
+    @play_script_reply = [0xB4, 3]
+    @get_bulk_reply = [0xBA, 3]
+    @multiple_set_hsh.each_pair do |k,v|
+      [@play_script_packed,@play_script_reply].each do |a|
+        a << k.bytesize
+        a << v.bytesize
+        a << k
+        a << v
+      end
+      [@multiple_set_packed,@get_bulk_reply].each do |a|
+        a << 0
+        a << k.bytesize
+        a << v.bytesize
+        a << EM::Tycoon::Protocol::Message::NO_XT_HEX
+        a << k
+        a << v
+      end
+    end
+    # XTs of "none" coming back in response are not 0x7FF...
+    @get_bulk_reply.collect! {|x| (x == EM::Tycoon::Protocol::Message::NO_XT_HEX) ? "000000ffffffffff" : x}
+    @multiple_set_packed = @multiple_set_packed.pack("CNN#{EM::Tycoon::Protocol::Message::KV_PACK_FMT*@multiple_set_hsh.keys.length}")
+    @multiple_get_packed = [0xBA, 0, 3, 
+                            0, "mykey1".bytesize, "mykey1",
+                            0, "my_longer_key2".bytesize, "my_longer_key2",
+                            0, "mykey3".bytesize, "mykey3"].pack("CNN"+("nNa*"*3))
+    @single_set_packed = [0xB8, 0, 1, 0,
+                          @single_set_keysize, @single_set_valuesize, "7#{'F'*15}",
+                          @single_set_hsh.keys.first, @single_set_hsh.values.first].pack("CNNnNNH*a*a*")
+    @single_get_packed = [0xBA, 0, 1, 0, "mykey".bytesize, "mykey"].pack("CNNnNa*")
+    
+    @single_remove_packed = [0xB9, 0, 1, 0, "mykey".bytesize, "mykey"].pack("CNNnNa*")
+    @multiple_remove_packed = [0xB9, 0, 3,
+                               0, "mykey1".bytesize, "mykey1",
+                               0, "my_longer_key2".bytesize, "my_longer_key2",
+                               0, "mykey3".bytesize, "mykey3"].pack("CNNnNa*nNa*nNa*")
+    @get_bulk_reply = @get_bulk_reply.pack("CN#{EM::Tycoon::Protocol::Message::KV_PACK_FMT*@multiple_set_hsh.keys.length}")
+    @set_bulk_reply = [0xB8, 2].pack("CN")
+    @remove_bulk_reply = [0xB9, 4].pack("CN")
+    @play_script_packed = @play_script_packed.pack("CNNNa*"+EM::Tycoon::Protocol::Binary::PlayScriptMessage::KV_PACK_FMT*@multiple_set_hsh.keys.length)
+    @play_script_reply = @play_script_reply.pack("CN#{EM::Tycoon::Protocol::Binary::PlayScriptMessage::KV_PACK_FMT*@multiple_set_hsh.keys.length}")
+  end
+  
+  it "Should generate a set_bulk message properly with one key/value pair" do
+    msg = EM::Tycoon::Protocol::Message.generate(:set, @single_set_hsh)
+    msg.should == @single_set_packed
+  end
+
+  it "Should generate a set_bulk message properly with multiple key/value pairs" do
+    msg = EM::Tycoon::Protocol::Message.generate(:set, @multiple_set_hsh)
+    msg.should == @multiple_set_packed
+  end
+
+  
+  it "Should parse a set_bulk reply properly" do
+    msg = EM::Tycoon::Protocol::Message.message_for(@set_bulk_reply)
+    bytes_parsed = msg.parse(@set_bulk_reply)
+    bytes_parsed.should == @set_bulk_reply.bytesize
+    msg.item_count.should be_kind_of(Integer)
+    msg.item_count.should == 2
+  end
+  
+  it "Should generate a get_bulk message properly with one key" do
+    msg = EM::Tycoon::Protocol::Message.generate(:get, "mykey")
+    msg.should == @single_get_packed
+  end
+
+  it "Should generate a get_bulk message properly with multiple keys" do
+    msg = EM::Tycoon::Protocol::Message.generate(:get, ["mykey1","my_longer_key2","mykey3"])
+    msg.should == @multiple_get_packed
+  end
+  
+  it "Should parse a get_bulk reply properly" do
+    msg = EM::Tycoon::Protocol::Message.message_for(@get_bulk_reply)
+    bytes_parsed = msg.parse(@get_bulk_reply)
+    bytes_parsed.should == @get_bulk_reply.bytesize
+    msg.item_count.should be_kind_of(Integer)
+    msg.item_count.should == 3
+    @multiple_set_hsh.each_pair do |k,v|
+      msg[k].should be_kind_of(Hash)
+      msg[k][:value].should == v
+      msg[k][:xt].should == nil   
+    end
+  end
+  
+  it "Should generate a remove_bulk message properly with one key" do
+    msg = EM::Tycoon::Protocol::Message.generate(:remove, "mykey")
+    msg.should == @single_remove_packed
+  end
+  
+  it "Should generate a remove_bulk message properly with multiple keys" do
+    msg = EM::Tycoon::Protocol::Message.generate(:remove, ["mykey1","my_longer_key2","mykey3"])
+    msg.should == @multiple_remove_packed
+  end
+  
+  it "Should parse a remove_bulk reply properly" do
+    msg = EM::Tycoon::Protocol::Message.message_for(@remove_bulk_reply)
+    bytes_parsed = msg.parse(@remove_bulk_reply)
+    bytes_parsed.should == @remove_bulk_reply.bytesize
+    msg.item_count.should be_kind_of(Integer)
+    msg.item_count.should == 4
+  end
+  
+  it "Should generate a play_script message properly" do
+    msg = EM::Tycoon::Protocol::Message.generate(:play_script, ["myscript", @multiple_set_hsh])
+    msg.should == @play_script_packed
+  end
+  
+  it "Should parse a play_script reply propery" do
+    msg = EM::Tycoon::Protocol::Message.message_for(@play_script_reply)
+    bytes_parsed = msg.parse(@play_script_reply)
+    bytes_parsed.should == @play_script_reply.bytesize
+    msg.item_count.should be_kind_of(Integer)
+    msg.item_count.should == 3
+    @multiple_set_hsh.each_pair do |k,v|
+      msg[k].should be_kind_of(Hash)
+      msg[k][:value].should == v
+    end
+  end
+end

data/spec/log/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

data/spec/online/binary_protocol_spec.rb

@@ -0,0 +1,69 @@
+require File.expand_path('../../spec_helper.rb', __FILE__)
+
+describe "Binary Protocol" do
+  include EM::Spec
+  
+  before(:all) do
+    ChildProcessManager.spawn({:cmd => "ktserver -host #{KT_OPTS[:host]} -port #{KT_OPTS[:port]} -scr #{File.dirname(__FILE__)}/../testscript.lua -log #{File.dirname(__FILE__)}/../log/ktserver.log -li ':#ktcapsiz=16m'",
+                               :port => KT_OPTS[:port]})
+    done
+  end
+  
+  after(:all) do
+    ChildProcessManager.reap_all
+    done
+  end
+  
+  it "Should support get and set operations with single KV pairs" do
+    client = EM::Tycoon.connect(KT_OPTS)
+    client.should be
+    client.set("key1" => "value1") { |result|
+      result.should == 1
+      client.get("key1") {|getresult|
+        getresult["key1"][:value].should == "value1"
+        client.remove("key1") {|removeresult|
+          removeresult.should == 1
+          done
+        }
+      }
+    }
+  end
+  
+  it "Should support get and set operations with multiple KV pairs" do
+    client = EM::Tycoon.connect(KT_OPTS)
+    client.should be
+    xt = Time.now+86400
+    kvs = {
+      "key1" => {:value => "value1", :xt => xt},
+      "key2" => {:value => "value2", :xt => xt} 
+      }
+    client.set(kvs) { |result|
+        result.should == 2
+        client.get(kvs.keys) {|getresult|
+          kvs.each_pair do |k,v|
+            getresult[k][:value].should == v[:value]
+            getresult[k][:dbidx].should == 0
+            getresult[k][:xt].should <= v[:xt]
+          end
+          client.remove(kvs.keys) {|removeresult|
+            removeresult.should == 2
+            done
+          }
+        }
+      }
+  end
+
+  it "Should support the play_script command" do
+    client = EM::Tycoon.connect(KT_OPTS)
+    client.should be
+    args = {"arg1" => "value1", "arg2" => "value2", "arg3" => "value3"}
+    client.play_script("testscript", args) { |result|
+      result.should be_kind_of(Hash)
+      args.each_pair do |k,v|
+        result[k][:value].should == args[k]
+      end
+      done
+    }
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+begin
+  require File.expand_path('../../.bundle/environment', File.dirname(__FILE__))
+rescue LoadError
+  require 'rubygems'
+  require 'bundler'
+
+  Bundler.setup(:default, :test)
+end
+require 'eventmachine'
+require 'rspec'
+require 'em-spec/rspec'
+require 'child-process-manager'
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end
+
+$LOAD_PATH << File.dirname(__FILE__) + '/../lib'
+require 'em-tycoon'
+
+KT_OPTS={:host => "localhost", :port => 1979}

data/spec/testscript.lua

@@ -0,0 +1,10 @@
+kt = __kyototycoon__
+db = kt.db
+
+function testscript(inmap, outmap)
+  kt.log("system", "testscript called")
+  for k,v in pairs(inmap) do
+    outmap[k] = v
+  end
+  return kt.RVSUCCESS
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: em-tycoon
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.9.0
+platform: ruby
+authors: 
+- Chris Ingrassia
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-08 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: An async client for Kyoto Tycoon's binary protocol using EventMachine
+email: 
+- chris@noneofyo.biz
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.rdoc
+- Rakefile
+- em-tycoon.gemspec
+- lib/em-tycoon.rb
+- lib/em/tycoon.rb
+- lib/em/tycoon/protocol/binary/error_message.rb
+- lib/em/tycoon/protocol/binary/get_message.rb
+- lib/em/tycoon/protocol/binary/play_script_message.rb
+- lib/em/tycoon/protocol/binary/remove_message.rb
+- lib/em/tycoon/protocol/binary/set_message.rb
+- lib/em/tycoon/protocol/message.rb
+- lib/em/tycoon/protocol/parser.rb
+- spec/kt_msg_spec.rb
+- spec/log/.gitignore
+- spec/online/binary_protocol_spec.rb
+- spec/spec_helper.rb
+- spec/testscript.lua
+has_rdoc: true
+homepage: http://github.com/andry1/em-tycoon
+licenses: []
+
+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: em-tycoon
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: EventMachine client for Kyoto Tycoon
+test_files: 
+- spec/kt_msg_spec.rb
+- spec/log/.gitignore
+- spec/online/binary_protocol_spec.rb
+- spec/spec_helper.rb
+- spec/testscript.lua