redis_failover-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 477b89feb234392eeeb44fb9dabd817f590bf5db
+  data.tar.gz: 3ef6dff5c7175ec11c21ae7fdee9220b77c18daf
+SHA512:
+  metadata.gz: edb014657c027a0f07d41026a6fe837ae9bcde3461eb7d9e80774be2548b8729dfc65080d8b5bdb848697df1fcb3775f93a5e4b6f3ceabfbe1240d6895d46218
+  data.tar.gz: 4e43aa4f71e251fcc9e799473bd54497062ce3dea4a4cc699f21e9802b8ce70c8be63a89f5b469d93296154675a722dd64b42fc8c8f5b1aa7ce7fdb8121de53b

data/.gitignore

@@ -0,0 +1,45 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+Gemfile.lock
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+log/*.log
+test/dummy/db/*.sqlite3
+test/dummy/db/*.sqlite3-journal
+test/dummy/log/*.log
+test/dummy/tmp/
+test/dummy/.sass-cache
+
+dump.rdb
+redis.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+gemspec
+
+gem "codeclimate-test-reporter", group: :test, require: nil

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Surfdome Shop Limited
+
+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,100 @@
+# redis_failover-rails
+
+[ ![Codeship Status for surfdome/redis_failover-rails](https://codeship.io/projects/1f022be0-c7b8-0131-24ea-6eafa0062d3a/status?branch=master)](https://codeship.io/projects/22198)
+[![Code Climate](https://codeclimate.com/github/surfdome/redis_failover-rails.png)](https://codeclimate.com/github/surfdome/redis_failover-rails)
+
+An ActiveSupport::Cache store using redis_failover (a zookeeper based implementation of HA redis) for Rails apps.
+
+This is based on the work done by [@wr0ngway](https://github.com/wr0ngway) (Matt Conway), available on [redis_failover_example](https://github.com/wr0ngway/redis_failover_example).
+
+Also, this gem utilizes redis_failover, a gem that creates a Redis HA implementation, using zookeeper for mantaining the available nodes.
+This can be found on [redis_failover](https://github.com/ryanlecompte/redis_failover).
+
+## Requirements
+In order to work, this requires a working [redis_failover](https://github.com/ryanlecompte/redis_failover) implementation. Please follow the instructions on the gem and ask your favourite Sysadmin/DevOps to implement in your environment.
+
+## Considerations
+In case you don't have a redis_failover implementation working, and for helping in the development process, this also works with a single node redis server.
+Just don't specify zkservers in the config file.
+
+## Installation
+
+Just add the dependency to your Gemfile...
+
+    # Gemfile
+    gem 'redis_failover-rails', github: 'surfdome/redis_failover-rails' # Not in rubygems.org, yet...
+
+ and run bundle install.
+
+    bundle install
+
+## Usage
+In your application.rb (or environment), you should use something like:
+
+    config.cache_store = :redis_cache_store, :cache
+    config.cache_classes = true
+    config.action_controller.perform_caching = true
+
+## Testing
+In order to make your tests work, you need a working redis_failover installation, with Redis, Zookeeper and Node Manager running on the ports specified in the default config file.
+
+Also you need a single redis server running on port 6379.
+
+For running the tests, just:
+
+    bundle exec rake
+
+## Configuration
+In order to define your redis and redis_failover configurations, you just need to use the `redis.yml` config file.
+
+This follows a format like this:
+
+    environment:
+      instance:
+        parameter1:
+        parameter2:
+
+This gem automatically selects a redis_failover client if you define `:zkservers` in the config file. If not, it just uses the standard redis client.
+
+This are the options available if you configure a redis_failover client:
+
+    :zk            - an existing ZK client instance
+    :zkservers     - comma-separated ZooKeeper host:port pairs
+    :znode_path    - the Znode path override for redis server list (optional)
+    :password      - password for redis nodes (optional)
+    :db            - db to use for redis nodes (optional)
+    :namespace     - namespace for redis nodes (optional)
+    :logger        - logger override (optional)
+    :retry_failure - indicate if failures should be retried (default true)
+    :max_retries   - max retries for a failure (default 3)
+    :safe_mode     - indicates if safe mode is used or not (default true)
+    :master_only   - indicates if only redis master is used (default false)
+    :verify_role   - verify the actual role of a redis node before every command (default true)
+
+Typical configuration parameters for standard redis clients are:
+
+    :host          - Redis server host
+    :port          - Redis server port
+    :db            - Redis database to use
+    :password      - Redis connection password
+
+Please keep in mind that this options are not validated, just passed to the client configuration.
+
+## License
+This gem is released with MIT licensing. Please see [LICENSE](https://github.com/surfdome/redis_failover-rails/blob/master/LICENSE) for details.
+
+## Author
+Initially created by Jose Pettoruti - [@jepettoruti](https://github.com/jepettoruti) for Surfdome.com
+
+## Acknowledgements
+This couldn't have been achieved without the work of [@ryanlecompte](https://github.com/ryanlecompte/) for making the amazing redis_failover gem.
+
+Special thanks to [@wr0ngway](https://github.com/wr0ngway) for his example on how to implement this on Rubber.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,22 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rake'
+require 'bundler/gem_tasks'
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Default: run unit tests.'
+task :default => :test

data/config/initializers/passenger.rb

@@ -0,0 +1,12 @@
+if defined?(PhusionPassenger)
+  PhusionPassenger.on_event(:starting_worker_process) do |forked|
+    if forked
+      # We're in smart spawning mode.
+
+      # Reset redis failover clients
+      RedisFactory.reconnect
+    else
+      # We're in conservative spawning mode. We don't need to do anything.
+    end
+  end
+end

data/config/redis.yml

@@ -0,0 +1,33 @@
+development:
+  cache:
+    host: localhost
+    port: 6380
+    thread_safe: true
+    zkservers: localhost:2181, localhost:2182, localhost:2183
+    znode_path: /redis_failover/nodes
+    db: 1
+
+production:
+  cache:
+    thread_safe: true
+    zkservers: localhost:2181, localhost:2182, localhost:2183
+    znode_path: /redis_failover
+    db: 0
+
+test:
+  hacache:
+    zkservers: localhost:2181
+    db: 8
+    thread_safe: true
+  myredisdb:
+    db: 1
+    host: localhost
+    port: 6379
+    thread_safe: true
+  cache:
+    db: 2
+    host: localhost
+    port: 6379
+    thread_safe: true
+
+

data/lib/active_support/cache/redis_cache_store.rb

@@ -0,0 +1,167 @@
+# require "backupify/logger_support"
+
+module ActiveSupport
+  module Cache
+
+    class RedisCacheStore < ActiveSupport::Cache::Store
+
+      # include Backupify::LoggerSupport
+
+      # Creates a new RedisStore object, with the given redis server
+      # address. Each address is a valid redis url string. For example:
+      #
+      #   ActiveSupport::Cache::RedisStore.new("redis://127.0.0.1:6379/0")
+      #
+      # Instead of addresses one can pass in a redis-like object. For example:
+      #
+      #   require 'redis' # gem install redis; uses C bindings to libredis
+      #   ActiveSupport::Cache::RedisStore.new(Redis.connect("localhost"))
+      def initialize(*connections)
+        options = connections.extract_options!
+        super(options)
+
+        raise ArgumentError, "Only a single connection must be provided" if connections.size > 1
+        connection = connections.first || options
+
+        if connection.respond_to?(:get)
+          @data = connection
+        elsif connection.is_a?(Symbol)
+          require 'redis_factory'
+          @data = RedisFactory.connect(connection)
+        else
+          redis_options = {}
+          if connection.is_a?(String)
+            redis_options[:url] = connection
+          elsif connection.is_a?(Hash)
+            redis_options = connection
+            ActiveSupport::Cache::UNIVERSAL_OPTIONS.each{|name| redis_options.delete(name)}
+          else
+            raise ArgumentError, "Need a url or hash for a redis connection"
+          end
+
+          @data = ::Redis.connect(redis_options)
+        end
+
+        extend ActiveSupport::Cache::Strategy::LocalCache
+      end
+
+      # Reads multiple values from the cache using a single call to the
+      # servers for all keys. Options can be passed in the last argument.
+      def read_multi(*names)
+        options = names.extract_options!
+        options = merged_options(options)
+        keys_to_names = Hash[names.map{|name| [namespaced_key(name, options), name]}]
+        raw_values = @data.mget(keys_to_names.keys)
+        values = {}
+        raw_values.each do |key, value|
+          entry = deserialize_entry(value)
+          values[keys_to_names[key]] = entry.value unless entry.expired?
+        end
+        values
+      end
+
+      # Delete objects for matched keys.
+      #
+      # Example:
+      #   cache.del_matched "rab*"
+      def delete_matched(matcher, options = nil) # :nodoc:
+        options = merged_options(options)
+        response = instrument(:delete_matched, matcher.inspect) do
+          matcher = key_matcher(matcher, options)
+          @data.keys(matcher).each { |key| @data.del key }
+        end
+      rescue => e
+        logger.error("Error calling delete_matched on redis: #{e}") if logger
+        nil
+      end
+
+      # Increment a cached value. This method uses the redis incrby atomic
+      # operator
+      def increment(name, amount = 1, options = nil) # :nodoc:
+        options = merged_options(options)
+        response = instrument(:increment, name, :amount => amount) do
+          @data.incrby(namespaced_key(name, options), amount)
+        end
+      rescue => e
+        logger.error("Error incrementing cache entry in redis: #{e}") if logger
+        nil
+      end
+
+      # Decrement a cached value. This method uses the redis decrby atomic
+      # operator
+      def decrement(name, amount = 1, options = nil) # :nodoc:
+        options = merged_options(options)
+        response = instrument(:decrement, name, :amount => amount) do
+          @data.decrby(namespaced_key(name, options), amount)
+        end
+      rescue => e
+        logger.error("Error decrementing cache entry in redis: #{e}") if logger
+        nil
+      end
+
+      # Clear the entire cache on all redis servers. This method should
+      # be used with care when shared cache is being used.
+      def clear(options = nil)
+        @data.flushdb
+      end
+
+      # Get the statistics from the redis servers.
+      def stats
+        @data.info
+      end
+
+      protected
+
+      # Read an entry from the cache.
+      def read_entry(key, options) # :nodoc:
+        deserialize_entry(@data.get(key))
+      rescue => e
+        logger.error("Error reading cache entry from redis: #{e}") if logger
+        nil
+      end
+
+      # Write an entry to the cache.
+      def write_entry(key, entry, options) # :nodoc:
+        value = serialize_entry(entry)
+        if (options && options[:expires_in])
+          expires_in = options[:expires_in].to_i
+          response = @data.setex(key, expires_in, value)
+        else
+          response = @data.set(key, value)
+        end
+      rescue => e
+        logger.error("Error writing cache entry to redis: #{e}") if logger
+        false
+      end
+
+      # Delete an entry from the cache.
+      def delete_entry(key, options) # :nodoc:
+        response = @data.del(key)
+      rescue => e
+        logger.error("Error deleting cache entry from redis: #{e}") if logger
+        false
+      end
+
+      private
+
+      def deserialize_entry(raw_value)
+        if raw_value
+          entry = Marshal.load(raw_value) rescue raw_value
+          entry.is_a?(ActiveSupport::Cache::Entry) ? entry : ActiveSupport::Cache::Entry.new(entry)
+        else
+          nil
+        end
+      end
+
+      def serialize_entry(entry)
+        if entry
+          Marshal.dump(entry)
+        else
+          nil
+        end
+      end
+
+    end
+
+  end
+end

data/lib/redis_factory.rb

@@ -0,0 +1,113 @@
+require 'redis_failover'
+
+# A factory class for creating redis connections, and reconnecting them after a fork
+#
+# It uses RedisFailover as the client if config/redis.yml contains a
+# zkservers setting for the named connection, otherwise vanilla redis client
+class RedisFactory
+  extend MonitorMixin
+
+  @@configuration = nil
+  @@clients = {}
+
+  def self.logger
+    Rails.logger
+  end
+
+  # Creates a redis client for the given named configuration
+  #
+  # @param [String] name The name of the redis configuration
+  #         (config/redis.yml) )to use
+  # @return [RedisClient] A redis client object
+  #         (may be a failover capable proxy)
+  def self.connect(name)
+    conf = configuration[name].symbolize_keys!
+    raise "No redis configuration for #{Rails.env} environment in redis.yml for #{name}" unless conf
+    synchronize do
+      # if conf[:zkservers]
+        # conf[:logger] = logger
+        # @@clients[name] ||= ::RedisFailover::Client.new(
+        #     :zkservers => 'localhost:2181,localhost:2182,localhost:2183',
+        #     :znode_path => '/redis_failover',
+        #     :db => '1')
+      # else
+        # @@clients[name] ||= ::Redis.new()
+      # end
+      if conf[:zkservers]
+        conf[:logger] = logger
+        @@clients[name] ||= ::RedisFailover::Client.new(conf)
+      else
+        @@clients[name] ||= ::Redis.new(conf)
+      end
+    end
+    @@clients[name]
+  end
+
+  def self.disconnect(key = nil)
+    logger.debug "RedisFactory.disconnect start"
+    synchronize do
+      @@clients.clone.each do |name, client|
+        next if key && name != key
+        client = @@clients.delete(name)
+        if client
+          begin
+            if client.instance_of?(::RedisFailover::Client)
+              logger.debug "Disconnecting RedisFailover client: #{client}"
+              client.shutdown
+            elsif client.instance_of?(::Redis)
+              logger.debug "Disconnecting Redis client: #{client}"
+              client.quit
+            else
+              logger.warn("Couldn't reconnect unknown redis client type: #{client.class}")
+            end
+          rescue => e
+            logger.warn("Exception while disconnecting: #{e}")
+          end
+        end
+      end
+    end
+    logger.debug "RedisFactory.disconnect complete"
+  end
+
+  def self.reconnect(key = nil)
+    logger.debug "RedisFactory.reconnect start"
+    synchronize do
+      @@clients.each do |name, client|
+        next if key && name != key
+        if client.instance_of?(::RedisFailover::Client)
+          logger.debug "Reconnecting RedisFailover client: #{client}"
+          client.reconnect
+        elsif client.instance_of?(::Redis)
+          logger.debug "Reconnecting Redis client: #{client}"
+          client.client.reconnect
+        else
+          logger.warn("Couldn't reconnect unknown redis client type: #{client.class}")
+        end
+      end
+    end
+    logger.debug "RedisFactory.reconnect complete"
+  end
+
+  def self.configuration
+    synchronize do
+      @@configuration ||= begin
+        require 'erb'
+        # config = YAML::load(ERB.new(IO.read("../config/redis.yml")).result)
+        config = YAML.load(ERB.new(File.read('./config/redis.yml')).result)
+        # self.symbolize(config[ENV['RAILS_ENV']])
+        config = config[ENV['RAILS_ENV']].symbolize_keys!
+      end
+    end
+  end
+
+  private
+
+  def self.symbolize(hash)
+    hash.inject({}) do |options, (key, value)|
+      value = self.symbolize(value) if value.kind_of?(Hash)
+      options[key.to_sym || key] = value
+      options
+    end
+  end
+
+end