aerospike-redis 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 78bff483bccb19c289b4446b28c96a33df6d3843
+  data.tar.gz: 4a959f3a78bbaa74d20d26876209985a66c45480
+SHA512:
+  metadata.gz: 7f51b2b8b22f0fe323cdd39c046b81db65873d6ccaf370791bd67b8a0062f5d91f0e45ac9e76c440b4f1deec1d362fa9797cce526836060c8de8645949cb08b8
+  data.tar.gz: d867984c44354f18d9c6fd98a8e0590c76c7ea8feebf2c06e8597867ba31701175f3ec7224ec2d6582151b7d8ba4318d598edb2e798c855e3de3157f8f97ebe5

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 amirrf
+
+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,90 @@
+# Aerospike Ruby Adapter for Redis
+[![Gem Version](https://badge.fury.io/rb/aerospike-redis.svg)](http://badge.fury.io/rb/aerospike-redis)
+
+Try Aerospike as a back-end replacement for Redis in Ruby applications.
+
+The aim of this gem is to facilitate trying Aerospike in your Redis-backed Ruby application without the need to learn a new API or modifications to existing codes, as long as the Redis commands used are within the subset supported by this gem.
+
+If you are using Redis as a cache or session store in Ruby on Rails applications, an Aerospike-backed cache and session store is already available: [Aerospike::Store](https://github.com/amirrf/aerospike-store-rails).
+
+Aerospike offers seamless clustering and SSD-optimized data persistence. Find out more about [Aerospike](http://www.aerospike.com).
+
+## Dependencies
+
+- [Aerospike Ruby Client](https://github.com/aerospike/aerospike-client-ruby)
+- [Redis Ruby Client](https://github.com/redis/redis-rb)
+
+These gems will be installed automatically using `bundle`.
+
+## Installation
+
+### Installation from RubyGems:
+
+    $ gem install aerospike-redis
+
+## Usage
+
+Specify Aerospike as the driver when creating the Redis client instance:
+
+```ruby
+require 'redis'
+require 'aerospike'
+require 'aerospike/redis'
+
+redis = Redis.new(:driver => :aerospike)
+```
+
+It is possible to pass Aerospike config options here. Defaults are:
+
+```ruby
+redis = Redis.new(:driver => :aerospike,
+                  :host => '127.0.0.1',
+                  :port => 3000,
+                  :namespace => 'test',
+                  :set => 'test',
+                  :bin => 'redis')
+```
+
+## How does it work
+
+It works as a driver for Redis client, redirecting Redis commands to Aerospike instead of writing to a Redis connection. Thanks to the extensible architecture of the [Redis Ruby Client](https://github.com/redis/redis-rb) that makes this possible.
+
+Parts of the Redis API are directly supported by the Aerospike API, while most of the functions are implemented through calling UDFs.
+
+## Supported commands
+
+Currently most of the Keys, Strings, and Lists commands are supported:
+
+### Keys
+`DEL`, `EXISTS`, `EXPIRE`, `EXPIREAT`, `PERSIST`, `PEXPIRE`, `PTTL`, `TTL`
+
+*Notes:* PEXPIRE and PTTL just convert milliseconds to seconds as Aerospike does not provide milliseconds precision to the client.
+
+### Strings
+`APPEND`, `DECR`, `DECRBY`, `GET`, `GETRANGE`, `GETSET`, `INCR`, `INCRBY`, `INCRBYFLOAT`, `MGET`, `MSET`, `MSETNX`, `PSETEX`, `SET`, `SETEX`, `SETNX`, `SETRANGE` ,`STRLEN`
+
+*Notes:* Implementation of `GETSET` is not atomic, it executes two separate commands from the client.
+
+### Lists
+`LINDEX`, `LINSERT`, `LLEN`, `LPOP`, `LPUSH`, `LPUSHX`, `LRANGE`, `LREM`, `LSET`, `LTRIM`, `RPOP`, `RPOPLPUSH`, `RPUSH`, `RPUSHX`
+
+*Notes:* Implementation of `RPOPLPUSHGETSET` is not atomic, it executes two separate commands from the client.
+
+## Testing
+A test suite is provided comparing the result of calling the same function through Aerospike vs. Redis.
+
+These tests are completely based on a subset of [Redis Ruby Client](https://github.com/redis/redis-rb) tests.
+
+    $ bundle exec rspec
+
+## Contributing
+
+1. Fork it ( https://github.com/amirrf/aerospike-redis-ruby/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## License
+
+The Aerospike-Redis-Ruby is made available under the terms of the Apache License, Version 2, as stated in the file `LICENSE`.

data/lib/aerospike/redis.rb

@@ -0,0 +1,7 @@
+require "aerospike/redis/version"
+require "redis/connection/aerospike"
+
+module Aerospike
+  module Redis
+  end
+end

data/lib/aerospike/redis/version.rb

@@ -0,0 +1,5 @@
+module Aerospike
+  module Redis
+    VERSION = "0.1.0"
+  end
+end

data/lib/redis/connection/aerospike.rb

@@ -0,0 +1,695 @@
+require "redis/connection/registry"
+require "redis/errors"
+require "timeout"
+require 'aerospike'
+
+class Redis
+  module Connection
+    class Aerospike
+      REDIS_UDF = 'redis_udf'
+
+      def self.connect(config)
+        config[:host] ||= '127.0.0.1'
+        config[:port] ||= 3000
+        connection = ::Aerospike::Client.new(config[:host], config[:port])
+
+        task =  connection.register_udf_from_file(File.join(File.dirname(File.expand_path(__FILE__)), REDIS_UDF) + '.lua',
+                                                  REDIS_UDF + '.lua', ::Aerospike::Language::LUA)
+        task.wait_till_completed()
+
+        #todo: support config[:timeout]
+
+        instance = new(connection)
+        instance.set_options(config)
+        instance
+      rescue Errno::ETIMEDOUT
+        raise TimeoutError
+      end
+
+      def set_options(config)
+        @namespace = config[:namespace] || 'test'
+        @set = config[:set] || 'test'
+        @bin = config[:bin] || 'redis'
+      end
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      def connected?
+        @connection && @connection.connected?
+      end
+
+      def timeout=(timeout)
+        #todo: support setting timeout
+      end
+
+      def disconnect
+        @connection.close
+        @connection = nil
+      end
+
+      def as_key(key_name)
+        return ::Aerospike::Key.new(@namespace, @set, key_name.to_s)
+      end
+
+
+      # EXISTS key
+      # Returns if key exists.
+      # Integer reply, specifically:
+      #    1 if the key exists.
+      #    0 if the key does not exist.
+      def process_exists(command)
+        key = command.first
+        @connection.exists(as_key(key))? 1 : 0
+      end
+
+
+      # DEL key [key ...]
+      # Removes the specified keys. A key is ignored if it does not exist.
+      # Integer reply: The number of keys that were removed.
+      def process_del(command)
+        result = 0
+        command.each do |key|
+          result += 1 if @connection.delete(as_key(key))
+        end
+        result
+      end
+
+      # EXPIRE key seconds
+      # Set a timeout on key. After the timeout has expired, the key will automatically be deleted. A key with an associated timeout is often said to be volatile in Redis terminology.
+      # Return value
+      # Integer reply, specifically:
+      #     1 if the timeout was set.
+      #     0 if key does not exist or the timeout could not be set.
+      def process_expire(command)
+        key = command[0]
+        seconds = command[1]
+        options = {:expiration => seconds }
+        @connection.touch(as_key(key), options)? 0 : 1  # return 1 when result is OK = 0
+      rescue ::Aerospike::Exceptions::Aerospike => e
+        if (e.result_code == ::Aerospike::ResultCode::KEY_NOT_FOUND_ERROR)
+          return 0
+        else
+          raise
+        end
+      end
+
+      # PEXPIRE key milliseconds
+      def process_pexpire(command)
+        command[1] /= 1000.0
+        process_expire(command)
+      end
+
+      # EXPIREAT key timestamp
+      # EXPIREAT has the same effect and semantic as EXPIRE, but instead of specifying the number of seconds representing the TTL (time to live), it takes an absolute Unix timestamp (seconds since January 1, 1970).
+      # Please for the specific semantics of the command refer to the documentation of EXPIRE.# Return value
+      # Integer reply, specifically:
+      #    1 if the timeout was set.
+      #    0 if key does not exist or the timeout could not be set (see: EXPIRE).
+      def process_expireat(command)
+        command[1] -=  Time.now.to_i
+        if command[1] > 0
+          process_expire(command)
+        else
+          process_del([command.first])
+        end
+      end
+
+      # PEXPIREAT key milliseconds-timestamp
+      def process_pexpireat(command)
+        command[1] /= 1000.0
+        process_expireat(command)
+      end
+
+      # TTL key
+      # Returns the remaining time to live of a key that has a timeout. This introspection capability allows a Redis client to check how many seconds a given key will continue to be part of the dataset.
+      # In Redis 2.6 or older the command returns -1 if the key does not exist or if the key exist but has no associated expire.
+      # Starting with Redis 2.8 the return value in case of error changed:
+      #     The command returns -2 if the key does not exist.
+      #     The command returns -1 if the key exists but has no associated expire.
+      # Return value
+      # Integer reply: TTL in seconds, or a negative value in order to signal an error (see the description above).
+      def process_ttl(command)
+        key = command.first
+        (header = @connection.get_header(as_key(key)))? (header.expiration == 0xFFFFFFFF? -1 : header.expiration) : -2
+      rescue ::Aerospike::Exceptions::Aerospike => e
+        if (e.result_code == ::Aerospike::ResultCode::KEY_NOT_FOUND_ERROR)
+          return -2
+        else
+          raise
+        end
+      end
+
+      # PTTL key
+      # Like TTL this command returns the remaining time to live of a key that has an expire set, with the sole difference that TTL returns the amount of remaining time in seconds while PTTL returns it in milliseconds
+      def process_pttl(command)
+        ttl = process_ttl(command)
+        (ttl > 0)? ttl * 1000 : ttl
+      end
+
+      # PERSIST key
+      # Remove the existing timeout on key, turning the key from volatile (a key with an expire set) to persistent (a key that will never expire as no timeout is associated).
+      # Return value
+      # Integer reply, specifically:
+      #     1 if the timeout was removed.
+      #     0 if key does not exist or does not have an associated timeout.
+      def process_persist(command)
+        key = command.first
+        options = {:expiration => -1 }
+        @connection.touch(as_key(key), options)? 0 : 1  # return 1 when result is OK = 0
+      rescue ::Aerospike::Exceptions::Aerospike => e
+        if (e.result_code == ::Aerospike::ResultCode::KEY_NOT_FOUND_ERROR)
+          return 0
+        else
+          raise
+        end
+      end
+
+      # TYPE key
+      # Returns the string representation of the type of the value stored at key. The different types that can be returned are: string, list, set, zset and hash.
+      # Return value
+      # Simple string reply: type of key, or none when key does not exist.
+      # def process_type(command)
+      #   key = command.first
+      #   if record = @connection.get(as_key(key))
+      #     value = record.bins[@bin]
+      #     if value.is_a? Integer
+      #       @result = 'integer'
+      #     else
+      #       @result = nil
+      #     end
+      #   else
+      #     @result = nil
+      #   end
+      # rescue ::Aerospike::Exceptions::Aerospike => e
+      #   if (e.result_code == ::Aerospike::ResultCode::KEY_NOT_FOUND_ERROR)
+      #     return 0
+      #   else
+      #     raise
+      #   end
+      # end
+
+
+
+      # SET key value [EX seconds] [PX milliseconds] [NX|XX]
+      # Set key to hold the string value. If key already holds a value, it is overwritten, regardless of its type. Any previous time to live associated with the key is discarded on successful SET operation.
+      # Options
+      #     EX seconds -- Set the specified expire time, in seconds.
+      #     PX milliseconds -- Set the specified expire time, in milliseconds.
+      #     NX -- Only set the key if it does not already exist.
+      #     XX -- Only set the key if it already exist.
+      # Simple string reply: OK if SET was executed correctly. Null reply: a Null Bulk Reply is returned if the SET operation was not performed becase the user specified the NX or XX option but the condition was not met.
+      def process_set(command)
+        key = command.slice!(0)
+        val = command.slice!(0)
+
+        options = {}
+        while !command.empty? do
+            case command.slice!(0)
+            when 'EX'
+              options[:expiration] = command.slice!(0)
+            when 'PX'
+              options[:expiration] = command.slice!(0) / 1000.0
+            when 'NX'
+              options[:record_exists_action] = ::Aerospike::RecordExistsAction::CREATE_ONLY
+            when 'XX'
+              options[:record_exists_action] = ::Aerospike::RecordExistsAction::UPDATE_ONLY
+            end
+          end
+
+          @connection.put(as_key(key), {@bin => val}, options)
+          return 'OK'
+        rescue ::Aerospike::Exceptions::Aerospike => e
+          if (e.result_code == ::Aerospike::ResultCode::KEY_NOT_FOUND_ERROR) || (e.result_code == ::Aerospike::ResultCode::KEY_EXISTS_ERROR)
+            return false
+          else
+            raise
+          end
+        end
+
+        # SETEX key seconds value
+        # Set key to hold the string value and set key to timeout after a given number of seconds. This command is equivalent to executing the following commands:
+        # SET mykey value
+        # EXPIRE mykey seconds
+        # Return value
+        # Simple string reply
+        def process_setex(command)
+          key = command[0]
+          seconds = command[1]
+          val = command[2]
+          options = {:expiration => seconds }
+          @connection.put(as_key(key), {@bin => val}, options)
+          return 'OK'
+        end
+
+        # PSETEX key milliseconds value
+        # PSETEX works exactly like SETEX with the sole difference that the expire time is specified in milliseconds instead of seconds.
+        def process_psetex(command)
+          command[1] /= 1000.0
+          process_setex(command)
+        end
+
+        # SETNX key value
+        # Set key to hold string value if key does not exist. In that case, it is equal to SET. When key already holds a value, no operation is performed. SETNX is short for "SET if N ot e X ists".
+        # Return value
+        # Integer reply, specifically:
+        #     1 if the key was set
+        #     0 if the key was not set
+        def process_setnx(command)
+          key = command[0]
+          val = command[1]
+          options = {:record_exists_action => ::Aerospike::RecordExistsAction::CREATE_ONLY}
+          @connection.put(as_key(key), {@bin => val}, options)
+          return 1
+        rescue ::Aerospike::Exceptions::Aerospike => e
+          if (e.result_code == ::Aerospike::ResultCode::KEY_EXISTS_ERROR)
+            return 0
+          else
+            raise
+          end
+        end
+
+        # GET key
+        # Get the value of key. If the key does not exist the special value nil is returned. An error is returned if the value stored at key is not a string, because GET only handles string values.
+        # Return value
+        # Bulk string reply: the value of key, or nil when key does not exist.
+        def process_get(command)
+          key = command.first
+          if record = @connection.get(as_key(key))
+            value = record.bins[@bin]
+          else
+            value = nil
+          end
+          value
+        rescue ::Aerospike::Exceptions::Aerospike => e
+          #          puts e.inspect
+          if (e.result_code == ::Aerospike::ResultCode::KEY_NOT_FOUND_ERROR)
+            return false
+          else
+            raise
+          end
+        end
+
+        # APPEND key value
+        # If key already exists and is a string, this command appends the value at the end of the string. If key does not exist it is created and set as an empty string, so APPEND will be similar to SET in this special case.
+        # Integer reply: the length of the string after the append operation.
+        def process_append(command)
+          key = command.first
+          val = command[1]
+          @connection.append(as_key(key), {@bin => val})
+
+          @connection.execute_udf(as_key(key), REDIS_UDF, 'strlen', [::Aerospike::StringValue.new(@bin)])
+        rescue ::Aerospike::Exceptions::Aerospike => e
+          if (e.result_code == ::Aerospike::ResultCode::KEY_EXISTS_ERROR)
+            return 0
+          else
+            raise
+          end
+        end
+
+        # STRLEN key
+        # Returns the length of the string value stored at key. An error is returned when key holds a non-string value.
+        # Return value
+        # Integer reply: the length of the string at key, or 0 when key does not exist.
+        def process_strlen(command)
+          key = command.first
+          @connection.execute_udf(as_key(key), REDIS_UDF, 'strlen', [::Aerospike::StringValue.new(@bin)])
+        rescue ::Aerospike::Exceptions::Aerospike => e
+          if (e.result_code == ::Aerospike::ResultCode::KEY_NOT_FOUND_ERROR)
+            return 0
+          else
+            raise
+          end
+        end
+
+        # GETRANGE key start end
+        # Warning: this command was renamed to GETRANGE, it is called SUBSTR in Redis versions <= 2.0.
+        # Returns the substring of the string value stored at key, determined by the offsets start and end (both are inclusive). Negative offsets can be used in order to provide an offset starting from the end of the string. So -1 means the last character, -2 the penultimate and so forth.
+        # The function handles out of range requests by limiting the resulting range to the actual length of the string.
+        # Return value
+        # Bulk string reply
+        def process_getrange(command)
+          key = command.first
+          @connection.execute_udf(as_key(key), REDIS_UDF, 'getrange',
+                                  [::Aerospike::StringValue.new(@bin),
+                                   ::Aerospike::IntegerValue.new(command[1]),
+                                   ::Aerospike::IntegerValue.new(command[2])
+                                   ])
+        end
+
+        # GETSET key value
+        # Atomically sets key to value and returns the old value stored at key. Returns an error when key exists but does not hold a string value.
+        def process_getset(command)
+          key = command.first
+          val = command[1]
+
+          if record = @connection.get(as_key(key))
+            old_value = record.bins[@bin]
+          else
+            old_value = nil
+          end
+          @connection.put(as_key(key), {@bin => val})
+          old_value
+        end
+
+
+
+        # INCR key
+        # Increments the number stored at key by one. If the key does not exist, it is set to 0 before performing the operation. An error is returned if the key contains a value of the wrong type or contains a string that can not be represented as integer. This operation is limited to 64 bit signed integers.
+        # Return value
+        # Integer reply: the value of key after the increment
+        def perform_add(key_name, add_value)
+          # bin_int = ::Aerospike::Bin.new(@bin, add_value)
+          # rec = @connection.operate(as_key(key_name), [
+          #                        ::Aerospike::Operation.add(bin_int),
+          #                        ::Aerospike::Operation.get(bin_int.name)
+          #   ])
+          # rec.bins[@bin]
+          #
+          # the above method does not work since add does not work on string bins! Error:  Bin type error
+          @connection.execute_udf(as_key(key_name), REDIS_UDF, 'add',
+                                  [::Aerospike::StringValue.new(@bin),
+                                   ::Aerospike::IntegerValue.new(add_value)
+                                   ])
+        end
+
+        def process_incr(command)
+          perform_add(command.first, +1)
+        end
+
+        # INCRBY key increment
+        # Increments the number stored at key by increment. If the key does not exist, it is set to 0 before performing the operation. An error is returned if the key contains a value of the wrong type or contains a string that can not be represented as integer. This operation is limited to 64 bit signed integers.
+        # Return value
+        # Integer reply: the value of key after the increment
+        def process_incrby(command)
+          perform_add(command.first, command[1])
+        end
+
+        def process_decr(command)
+          perform_add(command.first, -1)
+        end
+
+        def process_decrby(command)
+          perform_add(command.first, -1 * command[1])
+        end
+
+        # INCRBYFLOAT key increment
+        # Increment the string representing a floating point number stored at key by the specified increment. If the key does not exist, it is set to 0 before performing the operation. An error is returned if one of the following conditions occur:
+        #     The key contains a value of the wrong type (not a string).
+        #     The current key content or the specified increment are not parsable as a double precision floating point number.
+        # If the command is successful the new incremented value is stored as the new value of the key (replacing the old one), and returned to the caller as a string.
+        # Both the value already contained in the string key and the increment argument can be optionally provided in exponential notation, however the value computed after the increment is stored consistently in the same format, that is, an integer number followed (if needed) by a dot, and a variable number of digits representing the decimal part of the number. Trailing zeroes are always removed.
+        # The precision of the output is fixed at 17 digits after the decimal point regardless of the actual internal precision of the computation.
+        # Return value
+        # Bulk string reply: the value of key after the increment.
+        def process_incrbyfloat(command)
+          key = command.first
+          add_value = command[1]
+
+          @connection.execute_udf(as_key(key), REDIS_UDF, 'incrbyfloat',
+                                  [::Aerospike::StringValue.new(@bin),
+                                   ::Aerospike::StringValue.new(add_value.to_s)
+                                   ]).to_s
+        end
+
+
+        # SETRANGE key offset value
+        # Overwrites part of the string stored at key, starting at the specified offset, for the entire length of value. If the offset is larger than the current length of the string at key, the string is padded with zero-bytes to make offset fit. Non-existing keys are considered as empty strings, so this command will make sure it holds a string large enough to be able to set value at offset.
+        # Return value
+        # Integer reply: the length of the string after it was modified by the command.
+        def process_setrange(command)
+          key = command.first
+          offset = command[1]
+          value = command[2]
+
+          @connection.execute_udf(as_key(key), REDIS_UDF, 'setrange',
+                                  [::Aerospike::StringValue.new(@bin),
+                                   ::Aerospike::IntegerValue.new(offset),
+                                   ::Aerospike::StringValue.new(value)
+                                   ])
+          # CAUTION: zero-bytes mentioned in function description is replaced with spaces here
+        end
+
+
+
+        # MGET key [key ...]
+        # Returns the values of all specified keys. For every key that does not hold a string value or does not exist, the special value nil is returned. Because of this, the operation never fails.
+        # Return value
+        # Array reply: list of values at the specified keys.
+        def process_mget(command)
+          keys = command.map { |key| as_key(key) }
+          records = @connection.batch_get(keys, [@bin])
+          records.map { |rec| rec.nil?? nil : rec.bins[@bin] }
+        end
+
+        # MSET key value [key value ...]
+        # Sets the given keys to their respective values. MSET replaces existing values with new values, just as regular SET. See MSETNX if you don't want to overwrite existing values.
+        # MSET is atomic, so all given keys are set at once. It is not possible for clients to see that some of the keys were updated while others are unchanged.
+        # Return value
+        # Simple string reply: always OK since MSET can't fail.
+        def process_mset(command)
+          command.each_slice(2) { |kv|
+            key = kv[0]
+            val = kv[1]
+            begin
+              @connection.put(as_key(key), {@bin => val})
+            rescue ::Aerospike::Exceptions::Aerospike
+              # ignore and continue to set other keys
+            end
+          }
+          return 'OK'
+        end
+
+        # MSETNX key value [key value ...]
+        # Sets the given keys to their respective values. MSETNX will not perform any operation at all even if just a single key already exists.
+        # Because of this semantic MSETNX can be used in order to set different keys representing different fields of an unique logic object in a way that ensures that either all the fields or none at all are set.
+        # MSETNX is atomic, so all given keys are set at once. It is not possible for clients to see that some of the keys were updated while others are unchanged.
+        # Return value
+        # Integer reply, specifically:
+        #     1 if the all the keys were set.
+        #     0 if no key was set (at least one key already existed).
+        def process_msetnx(command)
+          keys = command.select.each_with_index { |str, i| i.even? }
+          if @connection.batch_exists(keys.map{ |key| as_key(key) }).reduce{|r,e| r || e}
+            return 0
+          else
+            command.each_slice(2) { |kv|
+              key = kv[0]
+              val = kv[1]
+              @connection.put(as_key(key), {@bin => val})
+            }
+            return 1
+          end
+        end
+
+
+        # LIST function ##############################################
+
+        # LPUSH key value [value ...]
+        # Insert all the specified values at the head of the list stored at key. If key does not exist, it is created as empty list before performing the push operations. When key holds a value that is not a list, an error is returned.
+        # It is possible to push multiple elements using a single command call just specifying multiple arguments at the end of the command. Elements are inserted one after the other to the head of the list, from the leftmost element to the rightmost element. So for instance the command LPUSH mylist a b c will result into a list containing c as first element, b as second element and a as third element.
+        # Return value
+        # Integer reply: the length of the list after the push operations.
+        def process_lpush(command)
+          key = command.slice!(0)
+          @connection.execute_udf(as_key(key), REDIS_UDF, 'lpush',
+                                  [::Aerospike::StringValue.new(@bin),
+                                   ::Aerospike::ListValue.new(command)
+                                   ])
+        end
+
+        # LPUSHX key value
+        # Inserts value at the head of the list stored at key, only if key already exists and holds a list. In contrary to LPUSH, no operation will be performed when key does not yet exist.
+        # Return value
+        # Integer reply: the length of the list after the push operation.
+        def process_lpushx(command)
+          key = command.first
+          val = command[1]
+          @connection.execute_udf(as_key(key), REDIS_UDF, 'lpushx',
+                                  [::Aerospike::StringValue.new(@bin),
+                                   ::Aerospike::StringValue.new(val)
+                                   ])
+        end
+
+        # LPOP key
+        # Removes and returns the first element of the list stored at key.
+        # Return value
+        # Bulk string reply: the value of the first element, or nil when key does not exist.
+        def process_lpop(command)
+          key = command.first
+          @connection.execute_udf(as_key(key), REDIS_UDF, 'lpop', [::Aerospike::StringValue.new(@bin)])
+        end
+
+
+        # RPUSH key value [value ...]
+        def process_rpush(command)
+          key = command.slice!(0)
+          @connection.execute_udf(as_key(key), REDIS_UDF, 'rpush',
+                                  [::Aerospike::StringValue.new(@bin),
+                                   ::Aerospike::ListValue.new(command)
+                                   ])
+        end
+
+        # RPUSHX key value
+        def process_rpushx(command)
+          key = command.first
+          val = command[1]
+          @connection.execute_udf(as_key(key), REDIS_UDF, 'rpushx',
+                                  [::Aerospike::StringValue.new(@bin),
+                                   ::Aerospike::StringValue.new(val)
+                                   ])
+        end
+
+        # RPOP key
+        def process_rpop(command)
+          key = command.first
+          @connection.execute_udf(as_key(key), REDIS_UDF, 'rpop',[::Aerospike::StringValue.new(@bin)])
+        end
+
+        # RPOPLPUSH source destination
+        def process_rpoplpush(command)
+          key1 = command.first
+          key2 = command[1]
+          value = @connection.execute_udf(as_key(key1), REDIS_UDF, 'rpop', [::Aerospike::StringValue.new(@bin)])
+          if (value != nil) then
+            @connection.execute_udf(as_key(key2), REDIS_UDF, 'lpush',
+                                    [::Aerospike::StringValue.new(@bin),
+                                     ::Aerospike::ListValue.new([value])
+                                     ])
+          end
+          value
+        end
+
+        # LLEN key
+        # Returns the length of the list stored at key. If key does not exist, it is interpreted as an empty list and 0 is returned. An error is returned when the value stored at key is not a list.
+        # Return value
+        # Integer reply: the length of the list at key.
+        def process_llen(command)
+          key = command.first
+          @connection.execute_udf(as_key(key), REDIS_UDF, 'llen', [::Aerospike::StringValue.new(@bin)])
+        end
+
+        # LSET key index value
+        # Sets the list element at index to value. For more information on the index argument, see LINDEX.
+        # An error is returned for out of range indexes.
+        # Return value
+        # Simple string reply
+        def process_lset(command)
+          key = command.first
+          index = command[1]
+          val = command[2]
+          @connection.execute_udf(as_key(key), REDIS_UDF, 'lset',
+                                  [::Aerospike::StringValue.new(@bin),
+                                   ::Aerospike::IntegerValue.new(index),
+                                   ::Aerospike::StringValue.new(val)
+                                   ])
+        end
+
+        # LINDEX key index
+        def process_lindex(command)
+          key = command.first
+          index = command[1]
+          @connection.execute_udf(as_key(key), REDIS_UDF, 'lindex',
+                                  [::Aerospike::StringValue.new(@bin),
+                                   ::Aerospike::IntegerValue.new(index)
+                                   ])
+        end
+
+        # LINSERT key BEFORE|AFTER pivot value
+        def process_linsert(command)
+          key = command.first
+          placement = command[1].to_s
+          pivot = command[2]
+          value = command[3]
+
+          @connection.execute_udf(as_key(key), REDIS_UDF, 'linsert',
+                                  [::Aerospike::StringValue.new(@bin),
+                                   ::Aerospike::StringValue.new(placement),
+                                   ::Aerospike::StringValue.new(pivot),
+                                   ::Aerospike::StringValue.new(value)
+                                   ])
+        end
+
+        def process_lrange(command)
+          key = command.first
+          start = command[1]
+          stop = command[2]
+
+          @connection.execute_udf(as_key(key), REDIS_UDF, 'lrange',
+                                  [::Aerospike::StringValue.new(@bin),
+                                   ::Aerospike::IntegerValue.new(start),
+                                   ::Aerospike::IntegerValue.new(stop)
+                                   ])
+        end
+
+        # LREM key count value
+        def process_lrem(command)
+          key = command.first
+          count = command[1]
+          value = command[2]
+
+          @connection.execute_udf(as_key(key), REDIS_UDF, 'lrem',
+                                  [::Aerospike::StringValue.new(@bin),
+                                   ::Aerospike::IntegerValue.new(count),
+                                   ::Aerospike::StringValue.new(value)
+                                   ])
+        end
+
+        # LTRIM key start stop
+        def process_ltrim(command)
+          key = command.first
+          start = command[1]
+          stop = command[2]
+
+          @connection.execute_udf(as_key(key), REDIS_UDF, 'ltrim',
+                                  [::Aerospike::StringValue.new(@bin),
+                                   ::Aerospike::IntegerValue.new(start),
+                                   ::Aerospike::IntegerValue.new(stop)
+                                   ])
+        end
+
+       def write(command)
+          #        @connection.write(command.flatten(1))
+          command = command.flatten(1)
+
+          # puts "write command: " + command.inspect
+
+          cmd = command.slice!(0)
+          # puts "command: " + cmd.to_s
+          # puts 'params: ' + command.to_s
+
+          method_name = 'process_' + cmd.to_s
+          if respond_to?(method_name)
+            @result = send(method_name, command)
+          else
+            raise "command not supported\n" + command.inspect
+          end
+          # puts "result was: " + @result.to_s
+          #        return @result
+
+        rescue Errno::EAGAIN
+          raise TimeoutError
+        end  # wrtie
+
+        def read
+          #        reply = @connection.read
+          #        reply = CommandError.new(reply.message) if reply.is_a?(RuntimeError)
+          #        reply
+
+          reply =  @result
+          @result = nil
+          return reply
+
+          #puts  "it is reading!"
+        rescue Errno::EAGAIN
+          raise TimeoutError
+        rescue RuntimeError => err
+          raise ProtocolError.new(err.message)
+        end # read
+
+    end # class AerospikeRedis
+  end # module Connection
+end # class Redis
+
+Redis::Connection.drivers << Redis::Connection::Aerospike

data/lib/redis/connection/redis_udf.lua

@@ -0,0 +1,365 @@
+-- General Error Codes -- this must line up with the Longevity LOOP code
+local ERR_SUCCESS        =   0; -- everything ok
+local ERR_READ_NOT_FOUND =   1; -- the expected value is not there
+local ERR_READ_FAILURE   =  -1; -- the bin or structure is wrong
+local ERR_WRITE_FAILURE  =  -2; -- problems with write or create
+local ERR_DELETE_FAILURE  = -3; -- problems with delete
+local ERR_UPDATE_FAILURE  = -4; -- problems with udpate
+
+
+function Hello(r)
+    return "Hello"
+end
+
+function echo_binName(topRec, binName)
+    return binName 
+end
+
+-- String support functions -----------------------------
+
+function strlen(topRec, binName)
+    if aerospike:exists(topRec) then 
+    	return string.len(topRec[binName]) 
+    else 
+    	return 0 
+    end
+end
+
+function add(topRec, binName, value)
+    if not aerospike:exists(topRec) then 
+        aerospike:create(topRec) 
+        topRec[binName] = 0
+    end
+    topRec[binName] = topRec[binName] + value
+    aerospike:update(topRec)
+    return topRec[binName]    
+end
+
+function incrbyfloat(topRec, binName, value)
+    if not aerospike:exists(topRec) then 
+        aerospike:create(topRec) 
+        topRec[binName] = '0'
+    end
+    topRec[binName] = tostring(tonumber(topRec[binName]) + tonumber(value))
+    aerospike:update(topRec)
+    return tostring(topRec[binName])
+end
+
+
+function getrange(topRec, binName, i, j)
+	if (i >= 0) then i = i + 1 end
+	if (j >= 0) then j = j + 1 end
+    if aerospike:exists(topRec) then 
+    	return string.sub(topRec[binName], i, j) 
+    else  
+    	return '' 
+    end
+end
+
+local function replace(s, offset, value)
+    if offset > string.len(s) then
+        -- s =  s ..  string.rep(string.char(0), offset - string.len(s))
+        -- this is not supported, so add spaces instead
+        s =  s ..  string.rep(' ', offset - string.len(s) - 1)
+    end
+    return string.sub(s, 1, offset - 1) .. value ..  string.sub(s, offset + string.len(value), string.len(s))
+end
+
+function setrange(topRec, binName, offset, value)
+    if (offset >= 0) then offset = offset + 1 end
+    if not aerospike:exists(topRec) then 
+        aerospike:create(topRec) 
+        topRec[binName] = ''
+    end
+    topRec[binName] = replace(topRec[binName], offset, value)
+    aerospike:update(topRec)
+    return string.len(topRec[binName])
+end
+
+
+-- List support functions -------------------------------
+
+function lpush(topRec, binName, values)
+    if not aerospike:exists(topRec) then 
+        aerospike:create(topRec) 
+        topRec[binName] = list()
+    end
+    local l = topRec[binName] 
+    for value in list.iterator(values) do
+        list.prepend(l, value)
+    end    
+    topRec[binName] = l
+    aerospike:update(topRec)
+    return list.size(topRec[binName])
+end
+
+function lpushx(topRec, binName, value)
+    if not aerospike:exists(topRec) then 
+        return 0
+    else
+        local l = topRec[binName]
+        list.prepend(l, value)
+        topRec[binName] = l
+        aerospike:update(topRec)
+        return list.size(topRec[binName])
+    end
+end
+
+function lpop(topRec, binName)
+    if not aerospike:exists(topRec) then 
+        return nil
+    else
+        local l = topRec[binName] 
+        if (list.size(l) == 0) then
+            return nil
+        else
+            local val = l[1]
+            topRec[binName] = list.drop(l, 1)
+            aerospike:update(topRec)
+            return val
+        end
+    end
+end
+
+function rpush(topRec, binName, values)
+    if not aerospike:exists(topRec) then 
+        aerospike:create(topRec) 
+        topRec[binName] = list()
+    end
+    local l = topRec[binName] 
+    for value in list.iterator(values) do
+        list.append(l, value)
+    end    
+    topRec[binName] = l
+    aerospike:update(topRec)
+    return list.size(topRec[binName])
+end
+
+function rpushx(topRec, binName, value)
+    if not aerospike:exists(topRec) then 
+        return 0
+    else
+        local l = topRec[binName]
+        list.append(l, value)
+        topRec[binName] = l
+        aerospike:update(topRec)
+        return list.size(topRec[binName])
+    end
+end
+
+function rpop(topRec, binName)
+    if not aerospike:exists(topRec) then 
+        return nil
+    else
+        local l = topRec[binName] 
+        if (list.size(l) == 0) then
+            return nil
+        else
+            local val = l[list.size(l)]
+            topRec[binName] = list.take(l, list.size(l) - 1)
+            aerospike:update(topRec)
+            return val
+        end
+    end
+end
+
+local function adjust_list_index(lst, index)
+    if (index >= 0) then
+        index = index + 1 -- lua lists are 1-based
+    else
+        index = list.size(lst) + index + 1
+    end
+    return index
+end
+
+--E, [2014-10-25T22:55:20.409949 #9060] ERROR -- : uninitialized constant IO::WaitWriteable
+--trying to access a list by a negative index or maybe there was an extra 'end' after  index = list.size(l) + index + 1
+function lset(topRec, binName, index, value)
+    if not aerospike:exists(topRec) then 
+        error( ERR_READ_NOT_FOUND )
+    else
+        local l = topRec[binName]
+        index = adjust_list_index(l, index)
+        if (index > list.size(l) or index < 1) then
+            error( ERR_UPDATE_FAILURE )
+        else
+            l[index] = value
+            topRec[binName] = l
+            aerospike:update(topRec)
+            return 'OK'
+        end
+    end
+end
+
+function lindex(topRec, binName, index)
+    if not aerospike:exists(topRec) then 
+        error( ERR_READ_NOT_FOUND )
+    else
+        local l = topRec[binName]
+        index = adjust_list_index(l, index)
+        if (index > list.size(l)) or (index < 1) then
+            return nil
+        else
+            return l[index]
+        end
+    end
+end
+
+-- List utility functions returning an empty list instead of nil
+local function merge_lists(list1, list2)
+    if not (list2 == nil) then
+        for val in list.iterator(list2) do
+            list.append(list1, val)
+        end
+    end
+    return list1
+end
+
+local function list_take(l, n)
+    if (n < 1) or (l == nil) then
+        return list()
+    else
+        return list.take(l, n)
+    end
+end
+
+local function list_drop(l, n)
+    if (l == nil) then
+        return list()
+    elseif (n < 1) then
+        return l
+    else
+        return list.drop(l, n)
+    end
+end
+-----------------------------------------------------------------
+
+function linsert(topRec, binName, placement, pivot, value)
+    if not aerospike:exists(topRec) then 
+        return nil
+    else
+        local l = topRec[binName]
+        local i = 0
+        for val in list.iterator(l) do
+            i = i + 1
+            if (val == pivot) then
+                if (string.upper(placement) == 'BEFORE') then
+                    i = i - 1
+                end
+
+                new_list = list_take(l, i)
+                list.append(new_list, value)
+                new_list = merge_lists(new_list, list_drop(l, i))
+
+                topRec[binName] = new_list
+                aerospike:update(topRec)
+                return list.size(topRec[binName])
+            end
+        end    
+        return -1 -- pivot not found
+    end
+end
+
+function llen(topRec, binName)
+    if not aerospike:exists(topRec) then 
+        return 0
+    else
+        return list.size(topRec[binName])
+    end
+end
+
+function lrange(topRec, binName, start, stop)
+    if not aerospike:exists(topRec) then 
+        return list()
+    else
+        local l = topRec[binName] 
+        start = adjust_list_index(l, start)
+        stop = adjust_list_index(l, stop)
+        l = list.merge(l, list())
+        l = list_drop(l, start - 1)
+        l = list_take(l, stop - start + 1)
+        return l
+    end
+end
+
+function lrem(topRec, binName, count, value)
+    if not aerospike:exists(topRec) then 
+        return 0
+    else
+        local l = topRec[binName] 
+        local new_list = list()
+        local rem_count = 0
+
+        if (count == 0) then -- remove all instances
+            for val in list.iterator(l) do
+                if (val == value) then
+                    rem_count = rem_count + 1
+                else
+                    list.append(new_list, val)
+                end
+            end
+        elseif (count > 0) then
+            for val in list.iterator(l) do
+                if (rem_count < count) and (val == value) then
+                    rem_count = rem_count + 1
+                else
+                    list.append(new_list, val)
+                end
+            end
+        else
+            for i = list.size(l), 1, -1 do
+                local val = l[i]
+                if (rem_count < -1 * count) and (val == value) then
+                    rem_count = rem_count + 1
+                else
+                    list.prepend(new_list, val)
+                end
+            end
+        end
+
+        topRec[binName] = new_list
+        aerospike:update(topRec)
+        return rem_count
+    end
+end
+
+function ltrim(topRec, binName, start, stop)
+    if aerospike:exists(topRec) then 
+        local l = topRec[binName]
+        start = adjust_list_index(l, start)
+        stop = adjust_list_index(l, stop)
+        l = list_drop(l, start - 1)
+        l = list_take(l, stop - start + 1)
+        if (list.size(l) == 0) then
+            aerospike:remove(topRec)
+        else
+            topRec[binName] = l
+            aerospike:update(topRec)
+        end
+    end
+    return 'OK'
+end
+
+
+-- Set support functions --------------------------------
+
+function sadd(topRec, binName, values)
+    if not aerospike:exists(topRec) then 
+        aerospike:create(topRec) 
+        topRec[binName] = list()
+    end
+    l = topRec[binName] 
+    for value in list.iterator(values) do
+        list.prepend(l, value)
+    end    
+    topRec[binName] = l
+    aerospike:update(topRec)
+    return list.size(topRec[binName])
+end
+
+
+
+
+--TODO use list.merge and list.clone to speed up things
+
+

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: aerospike-redis
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Amir Rahimi Farahani
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: aerospike
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+description: Try Aerospike as a back-end replacement for Redis in Ruby applications.
+email:
+- amirrf@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/aerospike/redis.rb
+- lib/aerospike/redis/version.rb
+- lib/redis/connection/aerospike.rb
+- lib/redis/connection/redis_udf.lua
+homepage: https://github.com/amirrf/aerospike-redis-ruby
+licenses:
+- Apache2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Aerospike Ruby Adapter for Redis.
+test_files: []