yapplabs-em-hiredis 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f65497178f2d00f8cd3ad0123616ebca02e5c424870a82bc808d7b1871ed9000
+  data.tar.gz: a5f59ff5c6e7a808c0b5a471a015cbbd7fb506fe6818b593ef3d061bb59112f6
+SHA512:
+  metadata.gz: 4e9cd348564dbe48d0621e57c962656753f1db0e10962c0b7c2b58723cab909b98374ac600fbbb7c4dd9ba7881e304b0b0db93a1685183675eee8292fbce73d5
+  data.tar.gz: 2ae7e11b4f1eab41987c47193ceb1447a46f978e78ad218064a61534623d724b337e530ad1c125810d80833c6d1021a5324a44b9b7fee2753f616446de3bacf6

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.DS_Store
+*.swp

data/.rspec

@@ -0,0 +1 @@
+--colour

data/CHANGELOG.md

@@ -0,0 +1,35 @@
+# Changelog
+
+## 0.3.0 (2014-06-30)
+
+[NEW] Lua script support (see README for details).
+
+[NEW] `Client#reconnect!` method which disconnects, reconfigures, and reconnects.
+
+[CHANGED] Locking abstraction re-implemented using lua (safer and simpler) [mdpye].
+
+[CHANGED] Hiredis dependency updated to 0.5.x
+
+## 0.2.1 (2013-04-22)
+
+[NEW] Support for connecting to redis on a unix socket.
+
+[CHANGED] Redis error reply message now used as message for RedisError.
+
+## 0.2.0 (2013-04-05)
+
+[NEW] Richer interface for pubsub (accessible via `client.pubsub`). See example in `examples/pubsub.rb`.
+
+[NEW] Better failure handling:
+
+  * Clients now emit the following events: connected, reconnected, disconnected, reconnect_failed (passes the number of consecutive failures)
+  * Client is considered failed after 4 consecutive failures
+  * Fails all queued commands when client failed
+  * Can now reconfiure and reconnect an exising client
+  * Reconnect timeout can be configured (defaults to 0.5s)
+
+[NEW] Added `EM::Hiredis::Lock` and `EM::Hiredis::PersistentLock`
+
+[CHANGE] When a redis command fails, the errback is now always passed an `EM::Hiredis::Error`.
+
+[FIX] Fixed info parsing for Redis 2.6

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENCE

@@ -0,0 +1,19 @@
+Copyright (C) 2011 by Martyn Loughran
+
+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,182 @@
+# em-hiredis
+
+## What
+
+A Redis client for EventMachine designed to be fast and simple.
+
+## Why
+
+I wanted a client which:
+
+* used the C hiredis library to parse redis replies
+* had a convenient API for pubsub
+* exposed the state of the underlying redis connections so that custom failover logic could be written outside the library
+
+Also, <https://github.com/madsimian/em-redis> is no longer maintained.
+
+## Getting started
+
+Connect to redis:
+
+    require 'em-hiredis'
+    redis = EM::Hiredis.connect
+
+Or, connect to redis with a redis URL (for a different host, port, password, DB)
+
+    redis = EM::Hiredis.connect("redis://:secretpassword@example.com:9000/4")
+
+Commands may be sent immediately. Any commands sent while connecting to redis will be queued.
+
+All redis commands are available without any remapping of names, and return a deferrable
+
+    redis.set('foo', 'bar').callback {
+      redis.get('foo').callback { |value|
+        p [:returned, value]
+      }
+    }
+
+If redis replies with an error (for example you called a hash operation against a set or the database is full), or if the redis connection disconnects before the command returns, the deferrable will fail.
+
+    redis.sadd('aset', 'member').callback {
+      response_deferrable = redis.hget('aset', 'member')
+      response_deferrable.errback { |e|
+        p e # => #<EventMachine::Hiredis::RedisError: Error reply from redis (wrapped in redis_error)>
+        p e.redis_error # => #<RuntimeError: ERR Operation against a key holding the wrong kind of value>
+      }
+    }
+
+As a shortcut, if you're only interested in binding to the success case you can simply provide a block to any command
+
+    redis.get('foo') { |value|
+      p [:returned, value]
+    }
+
+## Understanding the state of the connection
+
+When a connection to redis server closes, a `:disconnected` event will be emitted and the connection will be immediately reconnect. If the connection reconnects a `:connected` event will be emitted.
+
+If a reconnect fails to connect, a `:reconnect_failed` event will be emitted (rather than `:disconnected`) with the number of consecutive failures, and the connection will be retried after a timeout (defaults to 0.5s, can be set via `EM::Hiredis.reconnect_timeout=`).
+
+If a client fails to reconnect 4 consecutive times then a `:failed` event will be emitted, and any queued redis commands will be failed (otherwise they would be queued forever waiting for a reconnect).
+
+## Pubsub
+
+The way pubsub works in redis is that once a subscribe has been made on a connection, it's only possible to send (p)subscribe or (p)unsubscribe commands on that connection. The connection will also receive messages which are not replies to commands.
+
+The regular `EM::Hiredis::Client` no longer understands pubsub messages - this logic has been moved to `EM::Hiredis::PubsubClient`. The pubsub client can either be initialized directly (see code) or you can get one connected to the same redis server by calling `#pubsub` on an existing `EM::Hiredis::Client` instance.
+
+Pubsub can either be used in em-hiredis in a close-to-the-metal fashion, or you can use the convenience functionality for binding blocks to subscriptions if you prefer (recommended).
+
+### Close to the metal pubsub interface
+
+Basically just bind to `:message` and `:pmessage` events:
+
+    # Create two connections, one will be used for subscribing
+    redis = EM::Hiredis.connect
+    pubsub = redis.pubsub
+
+    pubsub.subscribe('bar.0').callback { puts "Subscribed" }
+    pubsub.psubscribe('bar.*')
+
+    pubsub.on(:message) { |channel, message|
+      p [:message, channel, message]
+    }
+
+    pubsub.on(:pmessage) { |key, channel, message|
+      p [:pmessage, key, channel, message]
+    }
+
+    EM.add_periodic_timer(1) {
+      redis.publish("bar.#{rand(2)}", "hello").errback { |e|
+        p [:publisherror, e]
+      }
+    }
+
+### Richer pubsub interface
+
+If you pass a block to `subscribe` or `psubscribe`, the passed block will be called whenever a message arrives on that subscription:
+
+    redis = EM::Hiredis.connect
+
+    puts "Subscribing"
+    redis.pubsub.subscribe("foo") { |msg|
+      p [:sub1, msg]
+    }
+
+    redis.pubsub.psubscribe("f*") { |channel, msg|
+      p [:sub2, msg]
+    }
+
+    EM.add_periodic_timer(1) {
+      redis.publish("foo", "Hello")
+    }
+
+    EM.add_timer(5) {
+      puts "Unsubscribing sub1"
+      redis.pubsub.unsubscribe("foo")
+    }
+
+It's possible to subscribe to the same channel multiple time and just unsubscribe a single callback using `unsubscribe_proc` or `punsubscribe_proc`.
+
+## Lua
+
+You can of course call EVAL or EVALSHA directly; the following is a higher-level API.
+
+Registering a named command on a redis client defines a ruby method with the given name on the client:
+
+    redis.register_script(:multiply, <<-END)
+      return redis.call('get', KEYS[1]) * ARGV[1]
+    END
+
+The method can be called in a very similar way to any other redis command; the only difference is that the first argument must be an array of keys, and the second (optional) an array of values.
+
+    # Multiplies the value at key foo by 2
+    redis.multiply(['foo'], [2]).callback { ... }
+
+Lua commands are submitted to redis using EVALSHA for efficiency. If redis replies with a NOSCRIPT error, the command is automatically re-submitted with EVAL; this is totally transparent to your code and the intermediate 'failure' will not be passed to your errback.
+
+You may register scripts globally, in which case they will be available to all clients:
+
+    EM::Hiredis::Client.register_script(:multiply, <<-END)
+      return redis.call('get', KEYS[1]) * ARGV[1]
+    END
+
+As a final convenience, it is possible to load all lua scripts from a directory automatically. All `.lua` files in the directory will be registered, and named according to filename (so a file called `sum.lua` becomes available as `redis.sum(...)`).
+
+    EM::Hiredis::Client.load_scripts_from('./lua_scripts')
+
+For examples see `examples/lua.rb` or `lib/em-hiredis/lock_lua`.
+
+## Inactivity checks
+
+Sometimes a network connection may hang in ways which are difficult to detect or involve very long timeouts before they can be detected from the application layer. This is especially true of Redis Pubsub connections, as they are not request-response driven. It is very difficult for a listening client to descern between a hung connection and a server with nothing to say.
+
+To start an application layer ping-pong mechanism for testing connection liveness, call the following at any time on a client:
+
+    redis.configure_inactivity_check(5, 3)
+
+This configures a `PING` command to be sent if 5 seconds elapse without receiving any data from the server, and a reconnection to be triggered if a futher 3 seconds elapse after the `PING` is submitted.
+
+This configuration is per client, you may choose different value for clients with different expected traffic patterns, or activate it on some and not at all on others.
+
+### PING and Pubsub
+
+Because the Redis Pubsub protocol limits the set of valid commands on a connection once it is in "Pubsub" mode, `PING` is not supported in this case (though it may be in future, see https://github.com/antirez/redis/issues/420). In order to create some valid request-response traffic on the connection, a Pubsub connection will issue `SUBSCRIBE "__em-hiredis-ping"`, followed by a corresponding `UNSUBSCRIBE` immediately on success of the subscribe.
+While less than ideal, this is the case where an application layer inactivity check is most valuable, and so the trade off is reasonable until `PING` is supported correctly on Pubsub connections.
+
+## TLS
+
+Redis 6 added TLS support. EM::Hiredis will interpret a rediss://... URL (note the extra s) as requiring TLS.
+
+## Developing
+
+You need bundler and a local redis server running on port 6379 to run the test suite.
+
+    # WARNING: The tests call flushdb on db 9 - this clears all keys!
+    bundle exec rake
+
+Run an individual spec:
+
+    bundle exec rspec spec/redis_commands_spec.rb
+
+Many thanks to the em-redis gem for getting this gem bootstrapped with some tests.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+end

data/examples/getting_started.rb

@@ -0,0 +1,14 @@
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'em-hiredis'
+
+EM.run {
+  redis = EM::Hiredis.connect
+  
+  redis.sadd('aset', 'member').callback {
+    response_deferrable = redis.hget('aset', 'member')
+    response_deferrable.errback { |e|
+      p e # => #<RuntimeError: ERR Operation against a key holding the wrong kind of value>
+      p e.redis_error
+    }
+  }
+}

data/examples/lua/sum.lua

@@ -0,0 +1,4 @@
+local a = redis.call('get', KEYS[1])
+local b = redis.call('get', KEYS[2])
+
+return a + b

data/examples/lua_example.rb

@@ -0,0 +1,35 @@
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'em-hiredis'
+
+EM.run do
+  scripts_dir = File.expand_path("../lua", __FILE__)
+  EM::Hiredis::Client.load_scripts_from(scripts_dir)
+
+  redis = EM::Hiredis.connect
+
+  redis.register_script(:multiply, <<-END)
+    return redis.call('get', KEYS[1]) * ARGV[1]
+  END
+
+  redis.set('foo', 42).callback {
+    redis.set('bar', 8).callback {
+
+      # Multiply is defined above.
+      # It is passed one key and one argument.
+      redis.multiply(['foo'], [2]).callback { |v|
+        puts "Multiply returned: #{v}"
+      }.errback { |e|
+        puts "Multiply error: #{e}"
+      }
+
+      # Sum is a lua script defined in sum.lua.
+      # It is passed two keys.
+      redis.sum(['foo', 'bar']).callback { |sum|
+        puts "Sum returned: #{sum}"
+      }.errback { |e|
+        puts "Sum error: #{e}"
+      }
+
+    }
+  }
+end

data/examples/pubsub_basics.rb

@@ -0,0 +1,24 @@
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'em-hiredis'
+
+EM.run {
+  redis = EM::Hiredis.connect
+  
+  puts "Subscribing"
+  redis.pubsub.subscribe("foo") { |msg|
+    p [:sub1, msg]
+  }
+  
+  redis.pubsub.psubscribe("f*") { |msg|
+    p [:sub2, msg]
+  }
+  
+  EM.add_periodic_timer(1) {
+    redis.publish("foo", "Hello")
+  }
+  
+  EM.add_timer(5) {
+    puts "Unsubscribing sub1"
+    redis.pubsub.unsubscribe("foo")
+  }
+}

data/examples/pubsub_more.rb

@@ -0,0 +1,51 @@
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'em-hiredis'
+
+EM.run {
+  redis = EM::Hiredis.connect
+  
+  # If you pass a block to subscribe it will be called whenever a message
+  # is received on this channel
+  redis.pubsub.subscribe('foo') { |message|
+    puts "Block received #{message}"
+  }
+  
+  # You can also pass any other object which responds to call if you wish
+  callback = Proc.new { |message|
+    "Proc received #{message}"
+  }
+  df = redis.pubsub.subscribe('foo', callback)
+  
+  # All calls return a deferrable
+  df.callback { |reply|
+    p [:subscription_succeeded, reply]
+  }
+  
+  # Passing such an object is useful if you want to unsubscribe
+  redis.pubsub.unsubscribe_proc('foo', callback)
+  
+  # Or if you want to call a method on a certain object
+  class Thing
+    def receive_message(message)
+      puts "Thing received #{message}"
+    end
+  end
+  redis.pubsub.subscribe('bar', Thing.new.method(:receive_message))
+  
+  # You can also get all the following raw events:
+  # message pmessage subscribe unsubscribe psubscribe punsubscribe
+  redis.pubsub.on(:message) { |channel, message|
+    p [:message_received, channel, message]
+  }
+  redis.pubsub.on(:unsubscribe) { |channel, remaining_subscriptions|
+    p [:unsubscribe_happened, channel, remaining_subscriptions]
+  }
+  
+  EM.add_timer(1) {
+    # You can also unsubscribe completely from a channel
+    redis.pubsub.unsubscribe('foo')
+    
+    # Publishing events
+    redis.publish('bar', 'Hello')
+  }
+}

data/examples/pubsub_raw.rb

@@ -0,0 +1,25 @@
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'em-hiredis'
+
+EM.run {
+  # Create two connections, one will be used for subscribing
+  redis = EM::Hiredis.connect
+  pubsub = redis.pubsub
+
+  pubsub.subscribe('bar.0').callback { puts "Subscribed" }
+  pubsub.psubscribe('bar.*')
+
+  pubsub.on(:message) { |channel, message|
+    p [:message, channel, message]
+  }
+
+  pubsub.on(:pmessage) { |key, channel, message|
+    p [:pmessage, key, channel, message]
+  }
+
+  EM.add_periodic_timer(1) {
+    redis.publish("bar.#{rand(2)}", "hello").errback { |e|
+      p [:publisherror, e]
+    }
+  }
+}