ConfigLoaders::Redis: basic redis-backed configuration

Intended to be wrapped by `Throttled` config loader.

n.b. if you use this, you will need to reset the redis configuration in your
`after_prefork` hook. (Until #135 handles it automatically.)

lib/resque/pool/config_loaders.rb

@@ -5,6 +5,7 @@ class Pool
  module ConfigLoaders
 
  autoload :FileOrHashLoader, "resque/pool/config_loaders/file_or_hash_loader"
+ autoload :Redis, "resque/pool/config_loaders/redis"
  autoload :Throttled, "resque/pool/config_loaders/throttled"
 
  end

lib/resque/pool/config_loaders/redis.rb

@@ -0,0 +1,65 @@
+require "resque"
+require "resque/pool"
+
+module Resque
+ class Pool
+ module ConfigLoaders
+
+ # Read/write pool config from redis.
+ # Should be wrapped in +ConfigLoaders::Throttled+.
+ #
+ # n.b. The environment needs to be passed in up-front, and will be ignored
+ # during +call+.
+ class Redis
+ attr_reader :redis
+ attr_reader :app, :pool, :env, :name
+
+ def initialize(app_name: Pool.app_name,
+ pool_name: Pool.pool_name,
+ environment: "unknown",
+ config_name: "config",
+ redis: Resque.redis)
+ @app = app_name
+ @pool = pool_name
+ @env = environment
+ @name = config_name
+ @redis = redis
+ end
+
+ # n.b. environment must be set up-front and will be ignored here.
+ def call(_)
+ redis.hgetall(key).tap do |h|
+ h.each do |k,v|
+ h[k] = v.to_i
+ end
+ end
+ end
+
+ # read individual worker config
+ def [](worker)
+ redis.hget(key, worker).to_i
+ end
+
+ # write individual worker config
+ def []=(worker, count)
+ redis.hset(key, worker, count.to_i)
+ end
+
+ # remove worker config
+ def delete(worker)
+ redis.multi do
+ redis.hget(key, worker)
+ redis.hdel(key, worker)
+ end.first.to_i
+ end
+
+ # n.b. this is probably namespaced under +resque+
+ def key
+ @key ||= ["pool", "config", app, pool, env, name].join(":")
+ end
+
+ end
+
+ end
+ end
+end

spec/config_loaders/redis_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+require 'resque/pool/config_loaders/redis'
+
+module Resque::Pool::ConfigLoaders
+
+ describe Redis do
+ before(:each) do
+ Resque.redis.flushdb
+ expect(Resque.redis.keys.count).to eq(0)
+ end
+
+ after(:all) do
+ Resque.redis.flushdb
+ end
+
+ subject(:config) { Redis.new(environment: env) }
+ subject(:env) { "prd" }
+
+ describe "initialization" do
+ it "uses default app_name and pool_name from Resque::Pool" do
+ expect(Redis.new.app).to eq(Resque::Pool.app_name)
+ expect(Redis.new.pool).to eq(Resque::Pool.pool_name)
+ end
+ it "uses default 'unknown' environment" do
+ expect(Redis.new.env).to eq("unknown")
+ end
+ it "uses default 'config' name" do
+ expect(Redis.new.name).to eq("config")
+ end
+ it "constructs redis key (expecting to be namespaced under resque)" do
+ config = Redis.new(app_name: "foo",
+ pool_name: "bar",
+ environment: "dev",
+ config_name: "override")
+ expect(config.key).to eq("pool:config:foo:bar:dev:override")
+ end
+ it "uses resque's redis connection (probably namespaced)" do
+ expect(Redis.new.redis).to eq(Resque.redis)
+ expect(Redis.new(redis: :another).redis).to eq(:another)
+ end
+ end
+
+ describe "basic API" do
+
+ it "starts out empty" do
+ expect(config.call(env)).to eq({})
+ end
+
+ it "has hash-like index setters" do
+ config["foo"] = 2
+ config["bar"] = 3
+ config["numbers_only"] = "elephant"
+ expect(config.call(env)).to eq({
+ "foo" => 2,
+ "bar" => 3,
+ "numbers_only" => 0,
+ })
+ end
+
+ it "has indifferent access (but call returns string keys)" do
+ config[:foo] = 1
+ config["foo"] = 2
+ expect(config[:foo]).to eq(2)
+ expect(config.call(env)).to eq("foo" => 2)
+ end
+
+ it "has hash-like index getters" do
+ config["foo"] = 86
+ config["bar"] = 99
+ expect(config["foo"]).to eq(86)
+ expect(config["bar"]).to eq(99)
+ expect(config["nonexistent"]).to eq(0)
+ end
+
+ it "can remove keys (not just set them to zero)" do
+ config["foo"] = 99
+ config["bar"] = 7
+ expect(config.delete("foo")).to eq(99)
+ expect(config.call(env)).to eq("bar" => 7)
+ end
+
+ end
+
+ describe "persistance" do
+
+ it "can be loaded from another instance" do
+ config["qA"] = 24
+ config["qB"] = 33
+ config2 = Redis.new environment: env
+ expect(config2.call(env)).to eq("qA" => 24, "qB" => 33)
+ end
+
+ it "won't clash with different configs" do
+ config[:foo] = 1
+ config[:bar] = 2
+ config2 = Redis.new app_name: "another"
+ expect(config2.call(env)).to eq({})
+ config3 = Redis.new pool_name: "another"
+ expect(config3.call(env)).to eq({})
+ config4 = Redis.new config_name: "another"
+ expect(config4.call(env)).to eq({})
+ config5 = Redis.new environment: "another"
+ expect(config5.call(env)).to eq({})
+ end
+
+ end
+
+ end
+
+end