infinispan-ruby-client 0.0.1

data/Gemfile.lock

@@ -0,0 +1,27 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.6.2)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.9.1)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.3)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  jeweler
+  rake
+  rspec (~> 2.1)

data/README.markdown

@@ -0,0 +1,75 @@
+# Infinispan Ruby Client
+
+[Infinispan](http://www.jboss.org/infinispan) is a scalable, high-availability
+data grid.  This is a native Ruby client implementation of Infinispan's [Hotrod
+client/server protocol](http://community.jboss.org/docs/DOC-14421), allowing
+Ruby applications to natively store and retrieve strings and Ruby objects in
+the Infinispan data grid.
+
+
+## Introduction
+
+This is a [Level-1
+client](http://community.jboss.org/wiki/HotRodProtocol#Client_Intelligence_1_byte),
+meaning that it is a basic client and does not participate in the data grid
+clustering.  The client currently only supports using the default cache, and
+all operations of the Hot Rod protocol are implemented except the [server
+stats](http://community.jboss.org/wiki/HotRodProtocol#stats_request)
+request.  
+
+## Installation
+
+    $ gem install infinispan-ruby-client
+
+## Usage
+
+Using the infinispan-ruby-client requires that you connect to an Infinispan
+server using the hotrod protocol.  
+
+1) First start Infinispan, specifying hotrod for the protocol 
+
+    $INFINISPAN_DIR/bin/startServer.sh -r hotrod
+
+2) Then write code
+
+    require 'infinispan-ruby-client'
+    cache = Infinispan::RemoteCache.new => #<Infinispan::RemoteCache:0x100365a78 @name="", @host="localhost", @port=11222> 
+
+    # Store and retrieve a string
+    cache.put("Name", "Lance") => true 
+    cache.get("Name") => "Lance" 
+
+    # Store and retrieve a ruby object
+    cache.put("Time", Time.now) => true
+    time = cache.get("Time") => Tue Jun 07 17:45:17 -0400 2011
+    time.class => Time
+
+
+## Todo
+* Support cache names 
+* Add ping operation before any call
+* Validate response headers
+* Get server statistics
+* Support for  lifespanSeconds and maxIdleTimeSeconds
+* Support for intelligent clients and topologies, and listeners
+* Configuration files support
+* Transaction support 
+* Support for Apache Avro Marshaller ??
+
+
+## License
+Copyright 2011 Red Hat, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+
+

data/lib/infinispan-ruby-client/constants.rb

@@ -0,0 +1,67 @@
+#
+# Copyright 2011 Red Hat, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module Infinispan
+  module Constants
+    MAGIC            = 0xA0, 0xA1
+    HT_VERSION       = 10
+
+    PUT              = 0x01, 0x02
+    GET              = 0x03, 0x04
+    PUT_IF_ABSENT    = 0x05, 0x06
+    REPLACE          = 0x07, 0x08
+    REPLACE_IF       = 0x09, 0x0A
+    REMOVE           = 0x0B, 0x0C
+    REMOVE_IF        = 0x0D, 0x0E
+    CONTAINS         = 0x0F, 0x10
+    GET_WITH_VERSION = 0x11, 0x12
+    CLEAR            = 0x13, 0x14
+    STATS            = 0x15, 0x16
+    PING             = 0x17, 0x18
+    BULK_GET         = 0x19, 0x1A
+    ERROR            = 0x50
+
+  end
+
+  module ResponseCode
+
+    SUCCESS             = 0x00
+    NO_ACTION           = 0x01
+    INVALID_KEY         = 0x02
+    INVALID_MAGIC       = 0x81
+    UNKNOWN_COMMAND     = 0x82
+    UNKNOWN_VERSION     = 0x83
+    REQUEST_PARSE_ERROR = 0x84
+    SERVER_ERROR        = 0x85
+    SERVER_TIME_OUT     = 0x86
+
+    def self.status_message( response_code )
+      case response_code
+      when SUCCESS             : "Success"
+      when NO_ACTION           : "No action taken"
+      when INVALID_KEY         : "Invalid key supplied"
+      when INVALID_MAGIC       : "Invalid magic or message"
+      when UNKNOWN_COMMAND     : "Unrecognized command"
+      when UNKNOWN_VERSION     : "Unrecognized version"
+      when REQUEST_PARSE_ERROR : "Request parse error"
+      when SERVER_ERROR        : "Server error"
+      when SERVER_TIME_OUT     : "Server timeout"
+      else                     
+        "Unrecognized response code: #{response_code.chr}"
+      end
+    end
+  end
+end

data/lib/infinispan-ruby-client/headerbuilder.rb

@@ -0,0 +1,39 @@
+#
+# Copyright 2011 Red Hat, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'infinispan-ruby-client/unsigned.rb'
+
+class HeaderBuilder
+  include Infinispan::Constants
+  def self.getHeader( op_code,cache_name )
+    result=[MAGIC[0].chr, #Magic
+            Unsigned.encodeVint(0x04), #Message Id
+            HT_VERSION.chr, # Version
+            op_code.chr, # Opcode
+            cache_name.size==0?[]:Unsigned.encodeVint(cache_name.size)] # Cache Name Length
+    
+    result<<cache_name unless cache_name.size==0 # # 	Cache Name
+    
+    tale=[0.chr, # Flags
+          0x01.chr, # Client Intelligence
+          0.chr, # Topology Id
+          0.chr, # Transaction Type
+          0.chr] # Transaction Id
+    
+    tale.each{|e| result<<e}
+    result
+  end
+end

data/lib/infinispan-ruby-client/remotecache.rb

@@ -0,0 +1,239 @@
+#
+# Copyright 2011 Red Hat, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'socket'
+
+module Infinispan
+  class RemoteCache
+    include Infinispan::Constants
+
+    attr_accessor :host, :port, :name
+
+    def initialize( host="localhost", port=11222, name="" )
+      @host = host
+      @port = port
+      @name = name
+    end
+
+    def ping
+      do_op( :operation => PING[0] )
+    end
+
+    def clear
+      do_op( :operation => CLEAR[0] )
+    end
+
+    def get( key )
+      do_op( :operation => GET[0], :key => key )
+    end
+
+    def get_bulk( count = 0 )
+      do_op( :operation => BULK_GET[0], :count => count )
+    end
+    
+    def put( key, value )
+      do_op( :operation => PUT[0], :key => key, :value => value )
+    end
+
+    def put_if_absent( key, value )
+      do_op( :operation => PUT_IF_ABSENT[0], :key => key, :value => value )
+    end
+
+    def get_versioned( key )
+      do_op( :operation => GET_WITH_VERSION[0], :key => key )
+    end
+
+    def contains_key?( key )
+      do_op( :operation => CONTAINS[0], :key => key )
+    end
+
+    alias_method :contains_key, :contains_key?
+
+    def remove( key )
+      do_op( :operation => REMOVE[0], :key => key )
+    end
+
+    def remove_if_unmodified( key, version )
+      do_op( :operation => REMOVE_IF[0], :key => key, :version => version )
+    end
+
+    def replace( key, value )
+      do_op( :operation => REPLACE[0], :key => key, :value => value )
+    end
+
+    def replace_if_unmodified( key, version, value )
+      do_op( :operation => REPLACE_IF[0], :key => key, :value => value, :version => version )
+    end
+
+    private
+    def do_op( options )
+      options[:cache] ||= @name
+
+      send_op    = Operation.send[ options[:operation] ]
+      recv_op    = Operation.receive[ options[:operation] ]
+
+      if (send_op && recv_op)
+        TCPSocket.open( @host, @port ) do |connection|
+          send_op.call( connection, options )
+          recv_op.call( connection )
+        end
+      else
+        raise "Unexpected operation: #{options[:operation]}"
+      end
+
+    end
+  end
+
+  module Operation
+
+    include Infinispan::Constants
+    include Infinispan::ResponseCode
+
+    def self.send 
+      {
+        GET[0]                      => KEY_ONLY_SEND,
+        GET_WITH_VERSION[0]         => KEY_ONLY_SEND,
+        BULK_GET[0]                 => BULK_GET_SEND,
+        PUT[0]                      => KEY_VALUE_SEND,
+        REMOVE[0]                   => KEY_ONLY_SEND,
+        REMOVE_IF[0]                => REMOVE_IF_SEND,
+        CONTAINS[0]                 => KEY_ONLY_SEND,
+        PUT_IF_ABSENT[0]            => KEY_VALUE_SEND,
+        REPLACE[0]                  => KEY_VALUE_SEND,
+        REPLACE_IF[0]               => REPLACE_IF_SEND,
+        CLEAR[0]                    => HEADER_ONLY_SEND,
+        PING[0]                     => HEADER_ONLY_SEND
+      }
+    end
+
+    def self.receive 
+      {
+        GET[0]                      => KEY_ONLY_RECV,
+        GET_WITH_VERSION[0]         => GET_WITH_VERSION_RECV,
+        BULK_GET[0]                 => BULK_GET_RECV,
+        PUT[0]                      => BASIC_RECV,
+        REMOVE[0]                   => BASIC_RECV,
+        REMOVE_IF[0]                => BASIC_RECV,
+        CONTAINS[0]                 => BASIC_RECV,
+        PUT_IF_ABSENT[0]            => BASIC_RECV,
+        REPLACE[0]                  => BASIC_RECV,
+        REPLACE_IF[0]               => BASIC_RECV,
+        CLEAR[0]                    => BASIC_RECV,
+        PING[0]                     => BASIC_RECV
+      }
+    end
+
+    HEADER_ONLY_SEND = lambda { |connection, options|
+      connection.write( HeaderBuilder.getHeader(options[:operation], options[:cache]) )
+    }
+
+    BULK_GET_SEND = lambda { |connection, options|
+      connection.write( HeaderBuilder.getHeader(options[:operation], options[:cache]) )
+      connection.write( Unsigned.encodeVint( options[:count] ) )
+    }
+
+    KEY_ONLY_SEND = lambda { |connection, options|
+      connection.write( HeaderBuilder.getHeader(options[:operation], options[:cache]) )
+      mkey = Marshal.dump( options[:key] )
+      connection.write( Unsigned.encodeVint( mkey.size ) )
+      connection.write( mkey )
+    }
+
+    KEY_VALUE_SEND = lambda { |connection, options|
+      connection.write( HeaderBuilder.getHeader(options[:operation], options[:cache]) )
+      # write key
+      mkey = Marshal.dump( options[:key] )
+      connection.write( Unsigned.encodeVint( mkey.size ) )
+      connection.write( mkey )
+
+      # lifespan + max_idle (not supported yet)
+      connection.write( [0x00.chr,0x00.chr] )
+
+      # write value
+      mkey = Marshal.dump( options[:value] )
+      connection.write( Unsigned.encodeVint( mkey.size ) )
+      connection.write( mkey )
+    }
+
+    REMOVE_IF_SEND = lambda { |connection, options|
+      connection.write( HeaderBuilder.getHeader(options[:operation], options[:cache]) )
+
+      # write key
+      key = Marshal.dump( options[:key] )
+      connection.write( Unsigned.encodeVint( key.size ) )
+      connection.write( key )
+
+      # write version
+      connection.write( options[:version] )
+    }
+
+    REPLACE_IF_SEND = lambda { |connection, options|
+      connection.write( HeaderBuilder.getHeader(options[:operation], options[:cache]) )
+
+      # write key
+      key = Marshal.dump( options[:key] )
+      connection.write( Unsigned.encodeVint( key.size ) )
+      connection.write( key )
+
+      # lifespan + max_idle (not supported yet)
+      connection.write( [0x00.chr,0x00.chr] )
+
+      # write version
+      connection.write( options[:version] )
+
+      # write value
+      value = Marshal.dump( options[:value] )
+      connection.write( Unsigned.encodeVint( value.size ) )
+      connection.write( value )
+    }
+
+    KEY_ONLY_RECV = lambda { |connection|
+      connection.read( 5 ) # The response header
+      response_body_length = Unsigned.decodeVint( connection )
+      response_body = connection.read( response_body_length )
+      Marshal.load( response_body )
+    }
+
+    GET_WITH_VERSION_RECV = lambda { |connection|
+      response_header = connection.read( 5 ) # The response header
+      version = connection.read( 8 )
+      response_body_length = Unsigned.decodeVint( connection )
+      response_body = connection.read( response_body_length )
+      [ version, Marshal.load( response_body ) ]
+    }
+
+    BULK_GET_RECV = lambda { |connection|
+      response = {}
+      response_header = connection.read( 5 ) # The response header
+      more = connection.read(1).unpack('c')[0]
+      while (more == 1) # The "more" flag
+        key_length = Unsigned.decodeVint( connection )
+        key = connection.read( key_length )
+        value_length = Unsigned.decodeVint( connection )
+        value = connection.read( value_length )
+        response[Marshal.load(key)] = Marshal.load(value)
+        more = connection.read(1).unpack('c')[0]
+      end
+      response
+    }
+
+    BASIC_RECV = lambda { |connection|
+      header = connection.read( 5 ) # Just the response header
+      header[3] == SUCCESS
+    }
+
+  end
+end

data/lib/infinispan-ruby-client/unsigned.rb

@@ -0,0 +1,39 @@
+#
+# Copyright 2011 Red Hat, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+class Unsigned
+	def self.encodeVint(i)
+		result=[]
+		while ((i & ~0x7f) != 0)
+			result[result.size]=((i & 0x7f) | 0x80).chr
+			i>>=7
+		end
+		result[result.size]=i.chr
+		result
+	end
+
+	def self.decodeVint(input)
+		b = input.read(1)
+    i = b[0] & 0x7F
+		shift = 7
+		while ((b[0] & 0x80) != 0)
+			b = input.read(1)
+      i |= (b[0] & 0x7F) << shift
+			shift += 7
+		end
+		i
+	end
+end

data/lib/infinispan-ruby-client.rb

@@ -0,0 +1,20 @@
+#
+# Copyright 2011 Red Hat, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'infinispan-ruby-client/constants.rb'
+require 'infinispan-ruby-client/headerbuilder.rb'
+require 'infinispan-ruby-client/remotecache.rb'
+require 'infinispan-ruby-client/unsigned.rb'

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification 
+name: infinispan-ruby-client
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Lance Ball
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-08 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: bundler
+  version_requirements: *id001
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: jeweler
+  version_requirements: *id002
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rake
+  version_requirements: *id003
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  type: :development
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 2
+        - 1
+        version: "2.1"
+  name: rspec
+  version_requirements: *id004
+  prerelease: false
+description: infinispan-hotrod-client provides native ruby access to the Infinispan Hotrod API
+email: lball@redhat.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- Gemfile.lock
+- README.markdown
+- lib/infinispan-ruby-client.rb
+- lib/infinispan-ruby-client/constants.rb
+- lib/infinispan-ruby-client/headerbuilder.rb
+- lib/infinispan-ruby-client/remotecache.rb
+- lib/infinispan-ruby-client/unsigned.rb
+has_rdoc: true
+homepage: https://github.com/lance/infinispan-ruby-client
+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: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Infinispan Hotrod Client
+test_files: []
+