gru 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2463532c5b329bff6e349b807995137e818c81fc
-  data.tar.gz: fc876dd69604baec04fa25b00c68fffac7e1ba5e
+  metadata.gz: f6abb6b68a1f26073ec9bfaa5ed2a858042db2b7
+  data.tar.gz: 4f43b5ef56312af91b6b2a675a55071817ef60a9
 SHA512:
-  metadata.gz: b8d6f5c0cdc9f0095f975d6e7857eea8e8f3f354dd10baf87495add5f99adbd632e1f865a23e97d456352c88c48da538d7e083805883ba14b402965fe8420484
-  data.tar.gz: 72d9b7e2741b39db85ebdc48a249ebd609b16fa68d7619b0ed94284cdb8c71ab2a4a6ea270c037802da40b46ecb25d07bb4946c5e9fd29024d15ded8d4503292
+  metadata.gz: dbc6158473909d36783371a088deaa48caf89eef61e8dd51b9222b24b11a04cc44ea8e6e52007aacc5b0bf172e753fb18295c117d6cf095714590ed3a5b2b029
+  data.tar.gz: 34990eb2f962112c7fffa308d149c6ce2183c5412cbcf957efc652d68e049e97ea483679e9a4930d361593b82a5361b32b81c68d8991e9717eca509831cab6ec

data/README.md

@@ -33,10 +33,13 @@ Or install it yourself as:
       end
     end
 
-    workers = { 'test_worker' => 5 }
-    global = { 'test_worker' => 10 }
-    manager = Gru.with_redis_connection(client,workers,global,true)
-    manager.register_worker_queues
+    settings = {
+      host_maximums: { 'test_worker' => 5 },
+      cluster_maximums: { 'test_worker' => 10 },
+      rebalance_flag: true
+    }
+
+    manager = Gru.create(settings)
     logger = Logger.new(STDOUT)
 
     loop do

data/lib/gru.rb

@@ -1,12 +1,12 @@
 require 'gru/version'
 require 'gru/worker_manager'
-require 'gru/adapters'
-require 'gru/adapters/redis_adapter'
+require 'gru/configuration'
 
 module Gru
-  def self.with_redis_connection(client, worker_config, global_config,balanced)
-    manager = WorkerManager.with_redis_connection(client,worker_config,global_config,balanced)
-    manager.register_worker_queues
+  def self.create(settings)
+    configuration = Gru::Configuration.new(settings)
+    manager = WorkerManager.new(configuration.adapter)
+    manager.register_workers
     manager
   end
 end

data/lib/gru/adapters/redis_adapter.rb

@@ -5,44 +5,43 @@ module Gru
     class RedisAdapter
       attr_reader :client
 
-      def initialize(client,global_config=nil)
+      def initialize(client,settings)
         @client = client
-        @global_config = global_config
+        @settings = settings
       end
 
-      def process_workers(workers)
-        register_workers(workers)
-        set_max_worker_counts(workers)
-        register_global_workers(@global_config || workers)
-        set_max_global_worker_counts(@global_config || workers)
+      def set_worker_counts
+        set_rebalance_flag(@settings.rebalance_flag)
+        register_workers(@settings.host_maximums)
+        set_max_worker_counts(@settings.host_maximums)
+        register_global_workers(@settings.cluster_maximums)
+        set_max_global_worker_counts(@settings.cluster_maximums)
       end
 
-      def provision_workers(balanced=false)
+      def provision_workers
         available = {}
         workers = max_host_workers
         workers.each do |worker, count|
-          i = 0
-          Integer(count).times do
-            if reserve_worker?(worker,balanced)
-              i += 1 if reserve_worker(worker)
+          available[worker] = with_worker_counts(worker,count) do |total|
+            if reserve_worker?(worker)
+              total += 1 if reserve_worker(worker)
             end
+            total
           end
-          available[worker] = i
         end
         available
       end
 
-      def expire_workers(balanced=false)
+      def expire_workers
         removable = {}
         workers = max_host_workers
         workers.each do |worker, count|
-          i = 0
-          Integer(count).times do
-            if expire_worker?(worker,balanced)
-              i -= 1 if expire_worker(worker)
+          removable[worker] = with_worker_counts(worker,count) do |total|
+            if expire_worker?(worker)
+              total -= 1 if expire_worker(worker)
             end
+            total
           end
-          removable[worker] = i
         end
         removable
       end
@@ -51,9 +50,15 @@ module Gru
         workers = max_host_workers
         workers.keys.each do |worker|
           host_running_count = local_running_count(worker)
+          running_count = host_running_count
+          global_running_count = host_running_count
           host_running_count.times do
-            send_message(:hincrby, global_workers_running_key,worker,-1)
-            send_message(:hincrby, host_workers_running_key,worker,-1)
+            if global_running_count > 0
+              global_running_count = send_message(:hincrby, global_workers_running_key,worker,-1)
+            end
+            if running_count > 0
+              running_count = send_message(:hincrby, host_workers_running_key,worker,-1)
+            end
           end
         end
         send_message(:del, host_workers_running_key)
@@ -75,23 +80,41 @@ module Gru
       end
 
       def set_max_global_worker_counts(workers)
-        workers.each_pair {|worker,count| set_max_global_worker_count(worker,count) }
+        reset_removed_global_worker_counts(workers)
+        workers.each_pair{|worker,count| set_max_global_worker_count(worker,count) }
+      end
+
+      def set_rebalance_flag(rebalance)
+        send_message(:set,"#{gru_key}:rebalance",rebalance)
       end
 
       def register_worker(worker,count)
-        send_message(:hset,"#{host_key}:workers_running",worker,count)
+        send_message(:hsetnx,host_workers_running_key,worker,count)
       end
 
       def register_global_worker(worker,count)
-        send_message(:hset,"#{global_key}:workers_running",worker,count)
+        send_message(:hsetnx,global_workers_running_key,worker,count)
       end
 
       def set_max_worker_count(worker,count)
-        send_message(:hset,"#{host_key}:max_workers",worker,count)
+        send_message(:hset,host_max_worker_key,worker,count)
       end
 
       def set_max_global_worker_count(worker,count)
-        send_message(:hset,"#{global_key}:max_workers",worker,count)
+        send_message(:hset,global_max_worker_key,worker,count)
+      end
+
+      def reset_removed_global_worker_counts(workers)
+        global_max = max_host_workers
+        global_max.each_pair do |worker, count|
+          set_max_global_worker_count(worker,0) unless workers[worker]
+        end
+      end
+
+      def with_worker_counts(worker,count,&block)
+        Integer(count).times.reduce(0) do |total|
+          block.call(total)
+        end
       end
 
       def reserve_worker(worker)
@@ -103,7 +126,7 @@ module Gru
       end
 
       def adjust_workers(worker,amount)
-        lock_key = "GRU:#{worker}"
+        lock_key = "#{gru_key}:#{worker}"
         if send_message(:setnx,lock_key,Time.now.to_i)
           send_message(:hincrby,host_workers_running_key,worker,amount)
           send_message(:hincrby,global_workers_running_key,worker,amount)
@@ -117,10 +140,14 @@ module Gru
         send_message(:hgetall,host_max_worker_key)
       end
 
-      def reserve_worker?(worker,balanced)
+      def max_global_workers
+        send_message(:hgetall,global_max_worker_key)
+      end
+
+      def reserve_worker?(worker)
         host_running,global_running,host_max,global_max = worker_counts(worker)
         result = false
-        if balanced
+        if rebalance_cluster?
           result = host_running.to_i < max_workers_per_host(global_max,host_max)
         else
           result = host_running.to_i < host_max.to_i
@@ -128,10 +155,10 @@ module Gru
           result && global_running.to_i < global_max.to_i
       end
 
-      def expire_worker?(worker,balanced)
+      def expire_worker?(worker)
         host_running,global_running,host_max,global_max = worker_counts(worker)
         result = false
-        if balanced
+        if rebalance_cluster?
           result = host_running.to_i > max_workers_per_host(global_max,host_max)
         else
           result = host_running.to_i > host_max.to_i
@@ -153,7 +180,7 @@ module Gru
       end
 
       def gru_host_count
-        send_message(:keys,"GRU:*:workers_running").count - 1
+        send_message(:keys,"#{gru_key}:*:workers_running").count - 1
       end
 
       def max_workers_per_host(global_worker_max_count,host_max)
@@ -162,6 +189,10 @@ module Gru
         rebalance_count <= host_max.to_i && host_count > 1 ? rebalance_count : host_max.to_i
       end
 
+      def rebalance_cluster?
+        send_message(:get,"#{gru_key}:rebalance") == "true"
+      end
+
       def host_max_worker_key
         "#{host_key}:max_workers"
       end
@@ -179,11 +210,15 @@ module Gru
       end
 
       def global_key
-        "GRU:global"
+        "#{gru_key}:global"
       end
 
       def host_key
-        "GRU:#{hostname}"
+        "#{gru_key}:#{hostname}"
+      end
+
+      def gru_key
+        "GRU:#{@settings.environment_name}:#{@settings.cluster_name}"
       end
 
       def hostname

data/lib/gru/configuration.rb

@@ -0,0 +1,26 @@
+require 'gru/adapters'
+require 'gru/adapters/redis_adapter'
+
+module Gru
+  class Configuration
+    attr_reader :cluster_maximums, :host_maximums, :rebalance_flag, :adapter, :cluster_name, :environment_name
+    def initialize(settings)
+      @host_maximums = settings.delete(:host_maximums) || settings.delete(:cluster_maximums)
+      @cluster_maximums = settings.delete(:cluster_maximums) || @host_maximums
+      @rebalance_flag = settings.delete(:rebalance_flag) || false
+      @cluster_name = settings.delete(:cluster_name) || 'default'
+      @environment_name = settings.delete(:environment_name) || 'default'
+      client = initialize_client(settings.delete(:redis_config))
+      @adapter = Gru::Adapters::RedisAdapter.new(client,self)
+      if @cluster_maximums.nil?
+        raise ArgumentError "Need at least a cluster configuration"
+      end
+    end
+
+    private
+
+    def initialize_client(config=nil)
+      Redis.new(config || {})
+    end
+  end
+end

data/lib/gru/version.rb

@@ -1,3 +1,3 @@
 module Gru
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/gru/worker_manager.rb

@@ -1,34 +1,21 @@
 module Gru
   class WorkerManager
-    attr_reader :workers, :adapter
+    attr_reader :adapter
 
-    def self.create(settings,workers)
-      redis = Redis.new(settings)
-      adapter = Gru::Adapters::RedisAdapter.new(redis)
-      new(adapter,workers)
-    end
-
-    def self.with_redis_connection(client,workers,global_config=nil,balanced=false)
-      adapter = Gru::Adapters::RedisAdapter.new(client,global_config)
-      new(adapter,workers,balanced)
-    end
-
-    def initialize(adapter,workers,balanced=false)
+    def initialize(adapter)
       @adapter = adapter
-      @workers = workers
-      @balanced = balanced
     end
 
-    def register_worker_queues
-      @adapter.process_workers(@workers)
+    def register_workers
+      @adapter.set_worker_counts
     end
 
     def provision_workers
-      @adapter.provision_workers(@balanced)
+      @adapter.provision_workers
     end
 
     def expire_workers
-      @adapter.expire_workers(@balanced)
+      @adapter.expire_workers
     end
 
     def adjust_workers

data/spec/gru/adapters/redis_adapter_spec.rb

@@ -1,19 +1,31 @@
 require 'rspec'
 require_relative '../../../lib/gru'
+require 'pry'
 
 describe Gru::Adapters::RedisAdapter do
   before(:each) do
     allow(Socket).to receive(:gethostname).and_return(hostname)
+    allow_any_instance_of(Gru::Configuration).to receive(:initialize_client).and_return(client)
   end
 
   let(:hostname) { 'foo' }
   let(:client) { double('client') }
+  let(:config) {
+    Gru::Configuration.new({
+      cluster_maximums: { 'test_worker' => 3 },
+      environment_name: 'environment',
+      cluster_name: 'cluster'
+    })
+  }
 
   let(:adapter) {
-    Gru::Adapters::RedisAdapter.new(client)
+    Gru::Adapters::RedisAdapter.new(client,config)
+  }
+
+  let(:gru_key) {
+    "GRU:#{config.environment_name}:#{config.cluster_name}"
   }
 
-  let(:workers) { { 'test_worker' => 3 } }
 
   context "initialization" do
     it "has a client" do
@@ -22,24 +34,28 @@ describe Gru::Adapters::RedisAdapter do
   end
 
   context "processing workers" do
-
     it "determines the host key" do
-      expect(adapter.send(:host_key)).to eq("GRU:#{hostname}")
+      expect(adapter.send(:host_key)).to eq("#{gru_key}:#{hostname}")
     end
 
     it "registers workers" do
-      expect(client).to receive(:hset).with("GRU:#{hostname}:workers_running",'test_worker',0)
-      adapter.send(:register_workers,workers)
+      expect(client).to receive(:hsetnx).with("#{gru_key}:#{hostname}:workers_running",'test_worker',0)
+      adapter.send(:register_workers,config.cluster_maximums)
     end
 
     it "sets worker counts" do
-      expect(client).to receive(:hset).with("GRU:#{hostname}:max_workers",'test_worker',3)
-      adapter.send(:set_max_worker_counts,workers)
+      expect(client).to receive(:hset).with("#{gru_key}:#{hostname}:max_workers",'test_worker',3)
+      adapter.send(:set_max_worker_counts,config.cluster_maximums)
     end
 
     it "sets global worker counts" do
-      expect(client).to receive(:hset).with("GRU:global:max_workers",'test_worker',3)
-      adapter.send(:set_max_global_worker_counts,workers)
+      expect(client).to receive(:hgetall).with("#{gru_key}:foo:max_workers").and_return({
+        'test_worker' => 2,
+        'foo_worker' => 5
+      })
+      expect(client).to receive(:hset).with("#{gru_key}:global:max_workers",'foo_worker',0)
+      expect(client).to receive(:hset).with("#{gru_key}:global:max_workers",'test_worker',3)
+      adapter.send(:set_max_global_worker_counts,config.cluster_maximums)
     end
 
   end
@@ -47,7 +63,7 @@ describe Gru::Adapters::RedisAdapter do
   context "Determining Available Workers" do
 
     it "gets all workers from redis" do
-      expect(client).to receive(:hgetall).with("GRU:#{hostname}:max_workers").and_return({
+      expect(client).to receive(:hgetall).with("#{gru_key}:#{hostname}:max_workers").and_return({
         'test_worker' => 3
       })
       adapter.send(:max_host_workers)
@@ -55,23 +71,24 @@ describe Gru::Adapters::RedisAdapter do
 
     context "Provisioning workers with same local and global max" do
       before(:each) do
-        expect(client).to receive(:hgetall).with("GRU:#{hostname}:max_workers").and_return(workers)
-        expect(client).to receive(:hget).with("GRU:#{hostname}:max_workers",'test_worker').exactly(1).times
-        expect(client).to receive(:hget).with("GRU:global:max_workers",'test_worker').exactly(1).times
-        expect(client).to receive(:hget).with("GRU:#{hostname}:workers_running",'test_worker').exactly(1).times
-        expect(client).to receive(:hget).with("GRU:global:workers_running",'test_worker').exactly(1).times
+        expect(client).to receive(:hgetall).with("#{gru_key}:#{hostname}:max_workers").and_return(config.cluster_maximums)
+        expect(client).to receive(:hget).with("#{gru_key}:#{hostname}:max_workers",'test_worker').exactly(1).times
+        expect(client).to receive(:hget).with("#{gru_key}:global:max_workers",'test_worker').exactly(1).times
+        expect(client).to receive(:hget).with("#{gru_key}:#{hostname}:workers_running",'test_worker').exactly(1).times
+        expect(client).to receive(:hget).with("#{gru_key}:global:workers_running",'test_worker').exactly(1).times
       end
 
       it "returns workers with 0 existing workers" do
         expect(client).to receive(:multi).exactly(3).times.and_yield(client).and_return([0,0,3,3])
         expect(client).to receive(:setnx).exactly(3).times.and_return(true)
-        expect(client).to receive(:del).with("GRU:test_worker").exactly(3).times
-        expect(client).to receive(:hincrby).with("GRU:global:workers_running",'test_worker',1).exactly(3).times
-        expect(client).to receive(:hincrby).with("GRU:#{hostname}:workers_running",'test_worker',1).exactly(3).times
-        expect(client).to receive(:hget).with("GRU:#{hostname}:max_workers",'test_worker').exactly(2).times
-        expect(client).to receive(:hget).with("GRU:global:max_workers",'test_worker').exactly(2).times
-        expect(client).to receive(:hget).with("GRU:#{hostname}:workers_running",'test_worker').exactly(2).times
-        expect(client).to receive(:hget).with("GRU:global:workers_running",'test_worker').exactly(2).times
+        expect(client).to receive(:del).with("#{gru_key}:test_worker").exactly(3).times
+        expect(client).to receive(:get).with("#{gru_key}:rebalance").exactly(3).times
+        expect(client).to receive(:hincrby).with("#{gru_key}:global:workers_running",'test_worker',1).exactly(3).times
+        expect(client).to receive(:hincrby).with("#{gru_key}:#{hostname}:workers_running",'test_worker',1).exactly(3).times
+        expect(client).to receive(:hget).with("#{gru_key}:#{hostname}:max_workers",'test_worker').exactly(2).times
+        expect(client).to receive(:hget).with("#{gru_key}:global:max_workers",'test_worker').exactly(2).times
+        expect(client).to receive(:hget).with("#{gru_key}:#{hostname}:workers_running",'test_worker').exactly(2).times
+        expect(client).to receive(:hget).with("#{gru_key}:global:workers_running",'test_worker').exactly(2).times
         available_workers = adapter.provision_workers
         expect(available_workers).to eq({'test_worker' => 3})
       end
@@ -79,53 +96,58 @@ describe Gru::Adapters::RedisAdapter do
       it "returns workers when max local and global counts have not been reached" do
         expect(client).to receive(:multi).exactly(3).times.and_yield(client).and_return([1,1,3,3])
         expect(client).to receive(:setnx).exactly(3).times.and_return(true)
-        expect(client).to receive(:del).with("GRU:test_worker").exactly(3).times
-        expect(client).to receive(:hincrby).with("GRU:global:workers_running",'test_worker',1).exactly(3).times
-        expect(client).to receive(:hincrby).with("GRU:#{hostname}:workers_running",'test_worker',1).exactly(3).times
-        expect(client).to receive(:hget).with("GRU:#{hostname}:max_workers",'test_worker').exactly(2).times
-        expect(client).to receive(:hget).with("GRU:global:max_workers",'test_worker').exactly(2).times
-        expect(client).to receive(:hget).with("GRU:#{hostname}:workers_running",'test_worker').exactly(2).times
-        expect(client).to receive(:hget).with("GRU:global:workers_running",'test_worker').exactly(2).times
+        expect(client).to receive(:del).with("#{gru_key}:test_worker").exactly(3).times
+        expect(client).to receive(:get).with("#{gru_key}:rebalance").exactly(3).times
+        expect(client).to receive(:hincrby).with("#{gru_key}:global:workers_running",'test_worker',1).exactly(3).times
+        expect(client).to receive(:hincrby).with("#{gru_key}:#{hostname}:workers_running",'test_worker',1).exactly(3).times
+        expect(client).to receive(:hget).with("#{gru_key}:#{hostname}:max_workers",'test_worker').exactly(2).times
+        expect(client).to receive(:hget).with("#{gru_key}:global:max_workers",'test_worker').exactly(2).times
+        expect(client).to receive(:hget).with("#{gru_key}:#{hostname}:workers_running",'test_worker').exactly(2).times
+        expect(client).to receive(:hget).with("#{gru_key}:global:workers_running",'test_worker').exactly(2).times
         available_workers = adapter.provision_workers
         expect(available_workers).to eq({'test_worker' => 3})
       end
 
       it "does not return workers if max global count has been reached" do
         expect(client).to receive(:multi).exactly(3).times.and_yield(client).and_return([0,3,3,3])
-        expect(client).to receive(:hget).with("GRU:#{hostname}:max_workers",'test_worker').exactly(2).times
-        expect(client).to receive(:hget).with("GRU:global:max_workers",'test_worker').exactly(2).times
-        expect(client).to receive(:hget).with("GRU:#{hostname}:workers_running",'test_worker').exactly(2).times
-        expect(client).to receive(:hget).with("GRU:global:workers_running",'test_worker').exactly(2).times
+        expect(client).to receive(:get).with("#{gru_key}:rebalance").exactly(3).times
+        expect(client).to receive(:hget).with("#{gru_key}:#{hostname}:max_workers",'test_worker').exactly(2).times
+        expect(client).to receive(:hget).with("#{gru_key}:global:max_workers",'test_worker').exactly(2).times
+        expect(client).to receive(:hget).with("#{gru_key}:#{hostname}:workers_running",'test_worker').exactly(2).times
+        expect(client).to receive(:hget).with("#{gru_key}:global:workers_running",'test_worker').exactly(2).times
         available_workers = adapter.provision_workers
         expect(available_workers).to eq({'test_worker' => 0})
       end
 
       it "doesn't return workers if max local count has been reached" do
         expect(client).to receive(:multi).exactly(3).times.and_yield(client).and_return([3,4,3,6])
-        expect(client).to receive(:hget).with("GRU:#{hostname}:max_workers",'test_worker').exactly(2).times
-        expect(client).to receive(:hget).with("GRU:global:max_workers",'test_worker').exactly(2).times
-        expect(client).to receive(:hget).with("GRU:#{hostname}:workers_running",'test_worker').exactly(2).times
-        expect(client).to receive(:hget).with("GRU:global:workers_running",'test_worker').exactly(2).times
+        expect(client).to receive(:get).with("#{gru_key}:rebalance").exactly(3).times
+        expect(client).to receive(:hget).with("#{gru_key}:#{hostname}:max_workers",'test_worker').exactly(2).times
+        expect(client).to receive(:hget).with("#{gru_key}:global:max_workers",'test_worker').exactly(2).times
+        expect(client).to receive(:hget).with("#{gru_key}:#{hostname}:workers_running",'test_worker').exactly(2).times
+        expect(client).to receive(:hget).with("#{gru_key}:global:workers_running",'test_worker').exactly(2).times
         reserved_workers = adapter.provision_workers
         expect(reserved_workers).to eq({'test_worker' => 0})
       end
 
       it "doesn't return workers if global max is 0" do
         expect(client).to receive(:multi).exactly(3).times.and_yield(client).and_return([0,0,3,0])
-        expect(client).to receive(:hget).with("GRU:#{hostname}:max_workers",'test_worker').exactly(2).times
-        expect(client).to receive(:hget).with("GRU:global:max_workers",'test_worker').exactly(2).times
-        expect(client).to receive(:hget).with("GRU:#{hostname}:workers_running",'test_worker').exactly(2).times
-        expect(client).to receive(:hget).with("GRU:global:workers_running",'test_worker').exactly(2).times
+        expect(client).to receive(:get).with("#{gru_key}:rebalance").exactly(3).times
+        expect(client).to receive(:hget).with("#{gru_key}:#{hostname}:max_workers",'test_worker').exactly(2).times
+        expect(client).to receive(:hget).with("#{gru_key}:global:max_workers",'test_worker').exactly(2).times
+        expect(client).to receive(:hget).with("#{gru_key}:#{hostname}:workers_running",'test_worker').exactly(2).times
+        expect(client).to receive(:hget).with("#{gru_key}:global:workers_running",'test_worker').exactly(2).times
         available_workers = adapter.provision_workers
         expect(available_workers).to eq({'test_worker' => 0})
       end
 
       it "doesn't provision workers if local max is 0" do
         expect(client).to receive(:multi).exactly(3).times.and_yield(client).and_return([0,1,0,3])
-        expect(client).to receive(:hget).with("GRU:#{hostname}:max_workers",'test_worker').exactly(2).times
-        expect(client).to receive(:hget).with("GRU:global:max_workers",'test_worker').exactly(2).times
-        expect(client).to receive(:hget).with("GRU:#{hostname}:workers_running",'test_worker').exactly(2).times
-        expect(client).to receive(:hget).with("GRU:global:workers_running",'test_worker').exactly(2).times
+        expect(client).to receive(:get).with("#{gru_key}:rebalance").exactly(3).times
+        expect(client).to receive(:hget).with("#{gru_key}:#{hostname}:max_workers",'test_worker').exactly(2).times
+        expect(client).to receive(:hget).with("#{gru_key}:global:max_workers",'test_worker').exactly(2).times
+        expect(client).to receive(:hget).with("#{gru_key}:#{hostname}:workers_running",'test_worker').exactly(2).times
+        expect(client).to receive(:hget).with("#{gru_key}:global:workers_running",'test_worker').exactly(2).times
         available_workers = adapter.provision_workers
         expect(available_workers).to eq({'test_worker' => 0})
       end
@@ -138,28 +160,29 @@ describe Gru::Adapters::RedisAdapter do
     }
 
     before(:each) do
-      expect(client).to receive(:hgetall).with("GRU:#{hostname}:max_workers").and_return(workers)
-      expect(client).to receive(:hget).with("GRU:#{hostname}:max_workers",'test_worker').exactly(1).times
-      expect(client).to receive(:hget).with("GRU:global:max_workers",'test_worker').exactly(1).times
-      expect(client).to receive(:hget).with("GRU:global:workers_running",'test_worker').exactly(1).times
-      expect(client).to receive(:hget).with("GRU:#{hostname}:workers_running",'test_worker').exactly(1).times
+      expect(client).to receive(:hgetall).with("#{gru_key}:#{hostname}:max_workers").and_return(workers)
+      expect(client).to receive(:hget).with("#{gru_key}:#{hostname}:max_workers",'test_worker').exactly(1).times
+      expect(client).to receive(:hget).with("#{gru_key}:global:max_workers",'test_worker').exactly(1).times
+      expect(client).to receive(:hget).with("#{gru_key}:global:workers_running",'test_worker').exactly(1).times
+      expect(client).to receive(:hget).with("#{gru_key}:#{hostname}:workers_running",'test_worker').exactly(1).times
+      expect(client).to receive(:get).with("#{gru_key}:rebalance").exactly(1).times
     end
 
     it "removes workers when local maximum has been exceeded" do
       expect(client).to receive(:multi).exactly(1).times.and_yield(client).and_return([3,3,1,3])
       expect(client).to receive(:setnx).exactly(1).times.and_return(true)
-      expect(client).to receive(:del).with("GRU:test_worker").exactly(1).times
-      expect(client).to receive(:hincrby).with("GRU:global:workers_running",'test_worker',-1).exactly(1).times
-      expect(client).to receive(:hincrby).with("GRU:#{hostname}:workers_running",'test_worker',-1).exactly(1).times
+      expect(client).to receive(:del).with("#{gru_key}:test_worker").exactly(1).times
+      expect(client).to receive(:hincrby).with("#{gru_key}:global:workers_running",'test_worker',-1).exactly(1).times
+      expect(client).to receive(:hincrby).with("#{gru_key}:#{hostname}:workers_running",'test_worker',-1).exactly(1).times
       expect(adapter.expire_workers).to eq({'test_worker' => -1})
     end
 
     it "removes workers when global maximum has been exceeded" do
       expect(client).to receive(:multi).exactly(1).times.and_yield(client).and_return([3,3,3,1])
       expect(client).to receive(:setnx).exactly(1).times.and_return(true)
-      expect(client).to receive(:del).with("GRU:test_worker").exactly(1).times
-      expect(client).to receive(:hincrby).with("GRU:global:workers_running",'test_worker',-1).exactly(1).times
-      expect(client).to receive(:hincrby).with("GRU:#{hostname}:workers_running",'test_worker',-1).exactly(1).times
+      expect(client).to receive(:del).with("#{gru_key}:test_worker").exactly(1).times
+      expect(client).to receive(:hincrby).with("#{gru_key}:global:workers_running",'test_worker',-1).exactly(1).times
+      expect(client).to receive(:hincrby).with("#{gru_key}:#{hostname}:workers_running",'test_worker',-1).exactly(1).times
       expect(adapter.expire_workers).to eq({'test_worker' => -1})
     end
 
@@ -177,22 +200,30 @@ describe Gru::Adapters::RedisAdapter do
   context "Rebalancing workers" do
 
     before(:each) do
-
     end
+    let(:config) {
+      Gru::Configuration.new({
+        cluster_maximums: { 'test_worker' => 3 },
+        environment_name: 'environment',
+        cluster_name: 'cluster',
+        rebalance_flag: true
+      })
+    }
 
     it "reduces load when workers are added" do
       expect(client).to receive(:multi).exactly(3).times.and_yield(client).and_return([2,4,3,5])
-      expect(client).to receive(:hgetall).with("GRU:#{hostname}:max_workers").and_return(workers)
-      expect(client).to receive(:hget).with("GRU:#{hostname}:workers_running",'test_worker').exactly(3).times
-      expect(client).to receive(:hget).with("GRU:global:workers_running",'test_worker').exactly(3).times
-      expect(client).to receive(:hget).with("GRU:#{hostname}:max_workers",'test_worker').exactly(3).times
-      expect(client).to receive(:hget).with("GRU:global:max_workers",'test_worker').exactly(3).times
-      expect(client).to receive(:keys).with("GRU:*:workers_running").exactly(3).times.and_return(['foo'])
+      expect(client).to receive(:hgetall).with("#{gru_key}:#{hostname}:max_workers").and_return(config.cluster_maximums)
+      expect(client).to receive(:hget).with("#{gru_key}:#{hostname}:workers_running",'test_worker').exactly(3).times
+      expect(client).to receive(:hget).with("#{gru_key}:global:workers_running",'test_worker').exactly(3).times
+      expect(client).to receive(:hget).with("#{gru_key}:#{hostname}:max_workers",'test_worker').exactly(3).times
+      expect(client).to receive(:hget).with("#{gru_key}:global:max_workers",'test_worker').exactly(3).times
+      expect(client).to receive(:keys).with("#{gru_key}:*:workers_running").exactly(3).times.and_return(['foo'])
       expect(client).to receive(:setnx).exactly(3).times.and_return(true)
-      expect(client).to receive(:hincrby).with("GRU:global:workers_running",'test_worker',1).exactly(3).times
-      expect(client).to receive(:hincrby).with("GRU:#{hostname}:workers_running",'test_worker',1).exactly(3).times
-      expect(client).to receive(:del).with("GRU:test_worker").exactly(3).times
-      adapter.provision_workers(true)
+      expect(client).to receive(:hincrby).with("#{gru_key}:global:workers_running",'test_worker',1).exactly(3).times
+      expect(client).to receive(:hincrby).with("#{gru_key}:#{hostname}:workers_running",'test_worker',1).exactly(3).times
+      expect(client).to receive(:del).with("#{gru_key}:test_worker").exactly(3).times
+      expect(client).to receive(:get).with("#{gru_key}:rebalance").and_return("true").exactly(3).times
+      adapter.provision_workers
 
     end
 

data/spec/gru/worker_manager_spec.rb

@@ -7,7 +7,7 @@ describe Gru::WorkerManager do
   }
 
   let(:manager) {
-    Gru::WorkerManager.new(adapter, workers)
+    Gru::WorkerManager.new(adapter)
   }
 
   let(:workers) {
@@ -15,10 +15,6 @@ describe Gru::WorkerManager do
   }
 
   context "When initialized" do
-    it "has workers" do
-      expect(manager.workers).not_to be_nil
-    end
-
     it "has an adapter instance" do
       expect(manager.adapter).not_to be_nil
     end
@@ -26,8 +22,8 @@ describe Gru::WorkerManager do
 
   context "Creating Worker Queues" do
     it "Creates workers" do
-      expect(adapter).to receive(:process_workers).with(workers).and_return(true)
-      manager.register_worker_queues
+      expect(adapter).to receive(:set_worker_counts).and_return(true)
+      manager.register_workers
     end
   end
 

metadata

@@ -1,97 +1,97 @@
 --- !ruby/object:Gem::Specification
 name: gru
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Jeffrey Gillis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-17 00:00:00.000000000 Z
+date: 2015-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - '>'
       - !ruby/object:Gem::Version
         version: '0.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - '>'
       - !ruby/object:Gem::Version
         version: '0.0'
 - !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: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: 3.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: 3.1.0
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - '>'
       - !ruby/object:Gem::Version
         version: '0.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - '>'
       - !ruby/object:Gem::Version
         version: '0.0'
 - !ruby/object:Gem::Dependency
   name: awesome_print
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - '>'
       - !ruby/object:Gem::Version
         version: '0.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - '>'
       - !ruby/object:Gem::Version
         version: '0.0'
 description: This is a worker/minion manager using different atomic data stores.
@@ -101,7 +101,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
+- .gitignore
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -110,6 +110,7 @@ files:
 - lib/gru.rb
 - lib/gru/adapters.rb
 - lib/gru/adapters/redis_adapter.rb
+- lib/gru/configuration.rb
 - lib/gru/version.rb
 - lib/gru/worker_manager.rb
 - spec/gru/adapters/redis_adapter_spec.rb
@@ -124,17 +125,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.4
 signing_key: 
 specification_version: 4
 summary: An atomic worker/minion manager.