workerholic 0.0.23 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 86a4ad33857310f6ae88067255e2ec98f0290e31
-  data.tar.gz: 0047fd7373d52d09e8d93a7f297ef9e9143657f9
+  metadata.gz: 6e37a5ab3f970c981fbabbad367f73e8fed83ad0
+  data.tar.gz: c2836310d4031983846dd8778dba6de4de4e624a
 SHA512:
-  metadata.gz: 2eccb9b6cccbec30b2c2c67232b6137fd8028b84a90dedc224698580bd3f4723785d617f00a9c7b9af338c611ba60ef1ef97dfbf1f4a2bd554a298c5e6bed026
-  data.tar.gz: d738cd59fefb6ef6abaff08ed10d07a5397a80c18db3b093aefb1fda4cb61f67f26084def316c955ad67c83161777308406215de653a0c3b973cf637f778b26b
+  metadata.gz: 5998191e60aa3a283434c85a5e7bf5e5a22b60ad27e8dbdbe459eef17418760613fa00a4a688087322ebc870cc1adedb07753a591ebba653f095f75f760121ba
+  data.tar.gz: 5f46779c52593659ace61aa4d4eb7a184549283bf3f2d0057cb31424dee5c43b110fde84f33225f7ca157028c159f8b05b95b7ea8ad21d1f25e85c5fe9598335

data/README.md

@@ -168,6 +168,24 @@ Use the following option if you want to have workers provisioned based on the lo
 
 This will ensure that each queue will be provisioned with a number of workers based on its relative load compared to the aggregated load for all job queues.
 
+#### Optimize by specifying IO-blocking jobs
+
+IO blocking jobs include, any type of jobs that will require the machine to spend some time on IO, such as performing requests over the wire, opening a file, `sleep`ing, etc.
+
+You can specify that your job is IO blocking by adding `-io` at the end of the queue name you specified in your job class, like the following:
+
+```ruby
+class MyJob < ApplicationJob
+  queue_as: 'my_queue-io'
+
+  def perform(args)
+    # job logic goes here
+  end
+end
+```
+
+In this case, the auto-balancing algorithm will assume that all other queues contain CPU blocking jobs and will assign only 1 worker to each of these queues, saving the rest of the workers for queues containing IO blocking jobs.
+
 ## Integration
 ### ActiveJob
 

data/lib/workerholic/job_retry.rb

@@ -12,7 +12,9 @@ module Workerholic
 
       increment_retry_count
       schedule_job_for_retry
-      sorted_set.add(JobSerializer.serialize(job), job.execute_at)
+      Workerholic.manager
+                 .scheduler
+                 .schedule(JobSerializer.serialize(job), job.execute_at)
     end
 
     private

data/lib/workerholic/manager.rb

@@ -7,7 +7,7 @@ module Workerholic
       @workers = []
       Workerholic.workers_count.times { @workers << Worker.new }
 
-      @scheduler = JobScheduler.new
+      @scheduler = JobScheduler.new(sorted_set: opts[:sorted_set])
       @worker_balancer = WorkerBalancer.new(workers: workers, auto_balance: opts[:auto_balance])
 
       @logger = LogManager.new

data/lib/workerholic/starter.rb

@@ -80,21 +80,18 @@ module Workerholic
     end
 
     def self.launch
-      if options[:processes] && options[:processes] > 1
-        begin
-          fork_processes
-          sleep
-        rescue SystemExit, Interrupt
-          exit
-        end
-      else
-        Manager.new(auto_balance: options[:auto_balance]).start
-      end
+      fork_processes if options[:processes] && options[:processes] > 1
+
+      Workerholic.manager = Manager.new(auto_balance: options[:auto_balance])
+      Workerholic.manager.start
     end
 
     def self.fork_processes
-      options[:processes].times do
-        PIDS << fork { Manager.new(auto_balance: options[:auto_balance]).start }
+      (options[:processes] - 1).times do
+        PIDS << fork do
+          Workerholic.manager = Manager.new(auto_balance: options[:auto_balance])
+          Workerholic.manager.start
+        end
       end
 
       PIDS.freeze

data/lib/workerholic/statistics_storage.rb

@@ -2,7 +2,6 @@ module Workerholic
   class StatsStorage
     def self.save_job(category, job)
       job_hash = job.to_hash
-      job_hash[:klass] = job.klass.to_s
       serialized_job_stats = JobSerializer.serialize(job_hash)
 
       namespace = "workerholic:stats:#{category}:#{job.klass}"

data/lib/workerholic/version.rb

@@ -1,3 +1,3 @@
 module Workerholic
-  VERSION = '0.0.23'
+  VERSION = '0.1.0'
 end

data/lib/workerholic/web/application.rb

@@ -1,4 +1,5 @@
 # $LOAD_PATH << __dir__ + '/../..'
+
 require 'sinatra/base'
 
 # require 'sinatra/reloader'
@@ -77,7 +78,6 @@ class WorkerholicWeb < Sinatra::Base
       failed_jobs: Workerholic::StatsAPI.job_statistics( {category: 'failed_jobs', count_only: true} ),
       queued_jobs: Workerholic::StatsAPI.queued_jobs,
       scheduled_jobs: Workerholic::StatsAPI.scheduled_jobs( { count_only: true }),
-      workers_count: Workerholic.workers_count,
       memory_usage: Workerholic::StatsAPI.process_stats,
       completed_jobs_per_second: Workerholic::StatsAPI.job_statistics_history('completed_jobs'),
     })

data/lib/workerholic/web/public/javascripts/application.js

@@ -4,7 +4,7 @@ var App = {
   jobsCompletedHistory: [],
   jobsCompletedPerSecondHistory: [],
   totalMemoryHistory: [],
-  maxTime: 240,
+  maxTime: 1000,
   pollingInterval: 10,
   chartFont: 'arial',
   freshDataCount: function() {
@@ -38,7 +38,6 @@ var App = {
       context: this,
       success: function(data) {
         var deserializedData = JSON.parse(data);
-        var workersCount = deserializedData.workers_count;
         var scheduledJobsCount = deserializedData.scheduled_jobs;
 
         var completedJobs = deserializedData.completed_jobs.reduce(function(sum, subArray) {
@@ -82,7 +81,6 @@ var App = {
         $('.queue_count').text(queuedJobs.length);
         $('.queued_jobs_count').text(queuedJobsCount);
         $('.scheduled_jobs').text(scheduledJobsCount);
-        $('.workers_count').text(workersCount);
         $('.memory_usage').text(totalMemoryUsage / 1000 + ' MB');
       }
     });
@@ -457,8 +455,7 @@ var App = {
     this.tab = $(location).attr('href').match(/(?:(?!\?).)*/)[0].split('/').pop();
     var $active = $('a[href=' + this.tab + ']');
 
-    $active.css('background', '#a2a2a2');
-    $active.css('color', '#fff');
+    $active.addClass('is-active');
   },
   pollData: function(tab) {
     if (tab === 'overview') {

data/lib/workerholic/web/public/stylesheets/application.css

@@ -5,43 +5,44 @@ body {
   background: #f2f2f2;
 }
 
-header {
+.nav {
   font-family: 'Dosis', sans-serif;
-  font-size: 128px;
-  color: #fff;
-  text-align: center;
-  background: linear-gradient(to bottom, #3A0E40, #E739FF);
 }
 
-section {
-  width: 1200px;
-  padding-bottom: 100px;
-  margin: 0 auto;
+.nav-item {
+  font-size: 20px;
+  color: #073763 !important;
 }
 
-footer p {
-  display: inline-block;
-  width: 100%;
-  text-align: center;
+.nav-item a:not(.button).is-tab:hover,
+a.nav-item:not(.button).is-tab:hover {
+  border-bottom: 1px solid #073763;
 }
 
-nav {
-  background: #fff;
+.nav-item a:not(.button).is-tab.is-active,
+a.nav-item:not(.button).is-tab.is-active {
+  border-bottom: 3px solid #073763;
 }
 
-nav a {
+#logo {
+  line-height: 1;
+}
+
+#logo img {
+  width: 200px;
+  max-height: 100px;
+}
+
+footer p {
   display: inline-block;
   width: 100%;
-  padding: 10px;
   text-align: center;
-  border-radius: 5px;
-  color: #000;
-  background: #cecece;
 }
 
-nav a:hover {
-  color: #fff;
-  background: #a2a2a2;
+section {
+  width: 1200px;
+  padding-bottom: 100px;
+  margin: 0 auto;
 }
 
 .table {

data/lib/workerholic/web/views/layout.erb

@@ -3,7 +3,7 @@
     <title>Workerholic Overview</title>
     <link href="https://fonts.googleapis.com/css?family=Dosis" rel="stylesheet">
     <link href="https://cdnjs.cloudflare.com/ajax/libs/bulma/0.4.4/css/bulma.css" rel="stylesheet">
-    <link href='stylesheets/application.css' rel='stylesheet'>
+    <link href="stylesheets/application.css" rel="stylesheet">
     <script src="https://canvasjs.com/assets/script/canvasjs.min.js"></script>
     <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
     <script src="javascripts/application.js"></script>
@@ -11,20 +11,23 @@
 
   <body>
     <header>
-      Workerholic
+      <nav class="nav has-shadow">
+        <div class="container">
+          <div class="nav-center">
+            <a class="nav-item" id="logo">
+              <img src="/images/workerholic_logo.png" alt="Workerholic logo">
+            </a>
+          </div>
+          <div class="nav-center">
+            <a class="nav-item is-tab is-hidden-mobile" href="overview">Overview</a>
+            <a class="nav-item is-tab is-hidden-mobile" href="details">Details</a>
+            <a class="nav-item is-tab is-hidden-mobile" href="queues">Queues</a>
+            <a class="nav-item is-tab is-hidden-mobile" href="history">History</a>
+          </div>
+        </div>
+      </nav>
     </header>
 
-    <nav>
-      <ul class='columns'>
-        <li class='column'><a href='overview'>Overview</a></li>
-        <li class='column'><a href='details'>Job Details</a></li>
-        <li class='column'><a href='queues'>Queues</a></li>
-        <li class='column'><a href='history'>History</a></li>
-        <!-- <li class='column'><a href='failed'>Failed</a></li>
-        <li class='column'><a href='scheduled'>Scheduled</a></li> -->
-      </ul>
-    </nav>
-
     <section>
       <%= yield %>
     </section>

data/lib/workerholic/web/views/overview.erb

@@ -26,10 +26,6 @@
       <td>Number of Queues</td>
       <td class='queue_count count'></td>
     </tr>
-    <tr>
-      <td>Number of Workers</td>
-      <td class='workers_count count'></td>
-    </tr>
     <tr id='memory_usage'>
       <td>Total Memory Usage</td>
       <td class='memory_usage count'></td>

data/lib/workerholic/worker.rb

@@ -16,8 +16,6 @@ module Workerholic
           serialized_job = poll
           JobProcessor.new(serialized_job).process if serialized_job
         end
-
-        #puts "DONE!"
       end
     rescue ThreadError => e
       @logger.info(e.message)

data/lib/workerholic/worker_balancer.rb

@@ -24,78 +24,64 @@ module Workerholic
       thread.kill
     end
 
-    private
+    private unless $TESTING
 
-    def auto_balance_workers
+    def evenly_balance_workers
       @thread = Thread.new do
         while alive
-          self.queues = fetch_queues
-
-          total_workers_count = assign_one_worker_per_queue
+          evenly_balanced_workers_distribution
+          output_balancer_stats
 
-          remaining_workers_count = workers.size - (total_workers_count + 1)
-          average_job_count_per_worker = total_jobs / remaining_workers_count.to_f
+          sleep 1
+        end
+      end
+    end
 
-          queues.each do |queue|
-            workers_count = queue.size / average_job_count_per_worker
+    def evenly_balanced_workers_distribution
+      self.queues = fetch_queues
 
-            if workers_count % 1 == 0.5
-              workers_count = workers_count.floor
-            else
-              workers_count = workers_count.round
-            end
+      total_workers_count = assign_one_worker_per_queue
 
-            assign_workers_to_queue(queue, workers_count, total_workers_count)
+      remaining_workers_count = workers.size - total_workers_count
 
-            total_workers_count += workers_count
-          end
+      queues.each do |queue|
+        workers_count = remaining_workers_count / queues.size
+        workers_count = round(workers_count)
 
-          distribute_unassigned_worker(total_workers_count)
-          output_balancer_stats
+        assign_workers_to_queue(queue, workers_count, total_workers_count)
 
-          sleep 2
-        end
+        total_workers_count += workers_count
       end
+
+      distribute_unassigned_worker(total_workers_count)
     end
 
-    def evenly_balance_workers
+    def auto_balance_workers
       @thread = Thread.new do
         while alive
-          self.queues = fetch_queues
-
-          total_workers_count = assign_one_worker_per_queue
-
-          remaining_workers_count = workers.size - (total_workers_count + 1)
-
-          queues.each do |queue|
-            workers_count = remaining_workers_count / queues.size
-            assign_workers_to_queue(queue, workers_count, total_workers_count)
-            total_workers_count += workers_count
-          end
-
-          distribute_unassigned_worker(total_workers_count)
+          auto_balanced_workers_distribution
           output_balancer_stats
 
-          sleep 2
+          sleep 1
         end
       end
     end
 
-    def distribute_unassigned_worker(total_workers_count)
-      workers[workers.size - 1].queue = queues.sample if workers.size - total_workers_count == 1
-    end
+    def auto_balanced_workers_distribution
+      self.queues = fetch_queues
 
-    def output_balancer_stats
-      queues_with_size = queues.map { |q| { name: q.name, size: q.size } }
+      total_workers_count = assign_one_worker_per_queue
 
-      queues_with_size.each do |q|
-        output = <<~LOG
-          Queue #{q[:name]}:
-          => #{q[:size]} jobs
-          => #{current_workers_count_per_queue[q[:name]]} workers
-        LOG
-        @logger.info(output)
-      end
+      remaining_workers_count = workers.size - total_workers_count
+      average_jobs_count_per_worker = total_jobs / remaining_workers_count.to_f
+
+      total_workers_count = provision_queues(io_queues, average_jobs_count_per_worker, total_workers_count)
+
+      distribute_unassigned_worker(total_workers_count)
+    end
+
+    def fetch_queues
+      storage.fetch_queue_names.map { |queue_name| Queue.new(queue_name) }
     end
 
     def assign_one_worker_per_queue
@@ -108,12 +94,31 @@ module Workerholic
       index
     end
 
-    def fetch_queues
-      storage.fetch_queue_names.map { |queue_name| Queue.new(queue_name) }
+    def total_jobs
+      io_queues.map(&:size).reduce(:+) || 0
     end
 
-    def total_jobs
-      @queues.map(&:size).reduce(:+) || 0
+    def io_queues
+      io_qs = queues.select { |q| q.name.match(/.*-io$/) }
+
+      if io_qs.empty?
+        queues
+      else
+        io_qs
+      end
+    end
+
+    def provision_queues(qs, average_jobs_count_per_worker, total_workers_count)
+      qs.each do |q|
+        workers_count = q.size / average_jobs_count_per_worker
+        workers_count = round(workers_count)
+
+        assign_workers_to_queue(q, workers_count, total_workers_count)
+
+        total_workers_count += workers_count
+      end
+
+      total_workers_count
     end
 
     def assign_workers_to_queue(queue, workers_count, total_workers_count)
@@ -122,6 +127,34 @@ module Workerholic
       end
     end
 
+    def round(n)
+      return n.floor if n % 1 == 0.5
+
+      n.round
+    end
+
+    def distribute_unassigned_worker(total_workers_count)
+      workers[workers.size - 1].queue = io_queues.find { |q| q.size == io_queues.map(&:size).max } if workers.size - total_workers_count == 1
+    end
+
+    def output_balancer_stats
+      queues_with_size = queues.map { |q| { name: q.name, size: q.size } }
+
+      queues_with_size.each do |q|
+        output = <<~LOG
+          Queue #{q[:name]}:
+          => #{q[:size]} jobs
+          => #{current_workers_count_per_queue[q[:name]]} workers
+        LOG
+        @logger.info(output)
+      end
+
+      if queues_with_size.empty?
+        @logger.info("DONE")
+        raise Interrupt
+      end
+    end
+
     def current_workers_count_per_queue
       workers.reduce({}) do |result, worker|
         if worker.queue

data/lib/workerholic.rb

@@ -43,7 +43,7 @@ module Workerholic
   end
 
   def self.redis_connections_count
-    @redis_connections_count || (workers_count + 5)
+    @redis_connections_count || (workers_count + 3)
   end
 
   def self.redis_connections_count=(num)
@@ -56,4 +56,12 @@ module Workerholic
       Redis.new(url: REDIS_URL)
     end
   end
+
+  def self.manager=(mgr)
+    @manager = mgr
+  end
+
+  def self.manager
+    @manager
+  end
 end

data/spec/helpers/helper_methods.rb

@@ -2,8 +2,12 @@ WORKERHOLIC_QUEUE_NAMESPACE = 'workerholic:queue:'
 
 TEST_QUEUE = 'test_queue'
 ANOTHER_TEST_QUEUE = 'another_test_queue'
-BALANCER_TEST_QUEUE = 'balancer_test_queue'
-ANOTHER_BALANCER_TEST_QUEUE = 'another_balancer_test_queue'
+
+FIRST_BALANCER_TEST_QUEUE = 'first_balancer_test_queue'
+SECOND_BALANCER_TEST_QUEUE = 'second_balancer_test_queue'
+THIRD_BALANCER_TEST_QUEUE = 'third_balancer_test_queue'
+FOURTH_BALANCER_TEST_QUEUE = 'fourth_balancer_test_queue'
+
 TEST_SCHEDULED_SORTED_SET = 'workerholic:testing:scheduled_jobs'
 HASH_TEST = 'workerholic:testing:hash_test'
 

data/spec/helpers/job_tests.rb

@@ -18,7 +18,7 @@ end
 
 class FirstJobBalancerTest
   include Workerholic::Job
-  job_options queue_name: BALANCER_TEST_QUEUE
+  job_options queue_name: FIRST_BALANCER_TEST_QUEUE
 
   def perform(str, n)
     str
@@ -27,7 +27,25 @@ end
 
 class SecondJobBalancerTest
   include Workerholic::Job
-  job_options queue_name: ANOTHER_BALANCER_TEST_QUEUE
+  job_options queue_name: SECOND_BALANCER_TEST_QUEUE
+
+  def perform(str, n)
+    str
+  end
+end
+
+class ThirdJobBalancerTest
+  include Workerholic::Job
+  job_options queue_name: THIRD_BALANCER_TEST_QUEUE
+
+  def perform(str, n)
+    str
+  end
+end
+
+class FourthJobBalancerTest
+  include Workerholic::Job
+  job_options queue_name: FOURTH_BALANCER_TEST_QUEUE
 
   def perform(str, n)
     str

data/spec/job_retry_spec.rb

@@ -8,6 +8,9 @@ end
 
 describe Workerholic::JobRetry do
   let(:redis) { Redis.new(url: Workerholic::REDIS_URL) }
+  before do
+    Workerholic.manager = Workerholic::Manager.new(sorted_set: Workerholic::SortedSet.new(TEST_SCHEDULED_SORTED_SET))
+  end
 
   it 'increments retry count' do
     job = Workerholic::JobWrapper.new(class: JobWithError, arguments: [])

data/spec/statistics_storage_spec.rb

@@ -19,6 +19,7 @@ describe Workerholic::StatsStorage do
     serialized_stats = storage.sorted_set_all_members(namespace).first
 
     expect(storage.sorted_set_size(namespace)).to eq 1
+    expect(serialized_stats).to eq(JSON.dump(job.to_hash))
   end
 
   it 'saves process memory usage' do

data/spec/worker_balancer_spec.rb

@@ -1,26 +1,248 @@
 require_relative 'spec_helper'
 
 TESTED_QUEUES = [
-  WORKERHOLIC_QUEUE_NAMESPACE + BALANCER_TEST_QUEUE,
-  WORKERHOLIC_QUEUE_NAMESPACE + ANOTHER_BALANCER_TEST_QUEUE
+  WORKERHOLIC_QUEUE_NAMESPACE + FIRST_BALANCER_TEST_QUEUE,
+  WORKERHOLIC_QUEUE_NAMESPACE + SECOND_BALANCER_TEST_QUEUE,
+  WORKERHOLIC_QUEUE_NAMESPACE + THIRD_BALANCER_TEST_QUEUE,
+  WORKERHOLIC_QUEUE_NAMESPACE + FOURTH_BALANCER_TEST_QUEUE
 ]
 
 describe Workerholic::WorkerBalancer do
   let(:storage) { Workerholic::Storage::RedisWrapper.new }
   let(:redis) { Redis.new(url: Workerholic::REDIS_URL) }
+  let(:workers) do
+    Array.new(25).map { Workerholic::Worker.new }
+  end
 
-  before do
+  it 'fetches queues' do
     100.times do |n|
       FirstJobBalancerTest.new.perform_async('first string', n)
       SecondJobBalancerTest.new.perform_async('second string', n)
+      ThirdJobBalancerTest.new.perform_async('third string', n)
+      FourthJobBalancerTest.new.perform_async('fourth string', n)
     end
-  end
 
-  it 'fetches queues' do
     allow(Workerholic::WorkerBalancer.new).to receive(:fetch_queues).and_return(TESTED_QUEUES)
 
     balancer = Workerholic::WorkerBalancer.new(workers: [])
 
     expect(balancer.queues.map(&:name)).to match_array(TESTED_QUEUES)
   end
+
+  context 'auto-balancing workers distribution' do
+    it 'does not throw an error when there are no queues' do
+      wb = Workerholic::WorkerBalancer.new(workers: workers, auto: true)
+
+      wb.auto_balanced_workers_distribution
+
+      expect(wb.current_workers_count_per_queue).to eq({})
+    end
+
+    it 'correctly distributes workers for 1 queue' do
+      100.times do |n|
+        FirstJobBalancerTest.new.perform_async('first string', n)
+      end
+      wb = Workerholic::WorkerBalancer.new(workers: workers, auto: true)
+
+      wb.auto_balanced_workers_distribution
+
+      expect(wb.current_workers_count_per_queue).to eq({ TESTED_QUEUES[0] => 25 })
+    end
+
+    it 'correctly distributes workers for 2 queues with equivalent loads' do
+      100.times do |n|
+        FirstJobBalancerTest.new.perform_async('first string', n)
+        SecondJobBalancerTest.new.perform_async('second string', n)
+      end
+      wb = Workerholic::WorkerBalancer.new(workers: workers, auto: true)
+
+      wb.auto_balanced_workers_distribution
+
+      expect(wb.current_workers_count_per_queue).to eq(
+        {
+          TESTED_QUEUES[0] => 12,
+          TESTED_QUEUES[1] => 13
+        }
+      )
+    end
+
+    it 'correctly distributes workers for 2 queues with uneven loads' do
+      100.times do |n|
+        FirstJobBalancerTest.new.perform_async('first string', n)
+      end
+
+      200.times do |n|
+        SecondJobBalancerTest.new.perform_async('second string', n)
+      end
+
+      wb = Workerholic::WorkerBalancer.new(workers: workers, auto: true)
+
+      wb.auto_balanced_workers_distribution
+
+      expect(wb.current_workers_count_per_queue).to eq(
+        {
+          TESTED_QUEUES[0] => 9,
+          TESTED_QUEUES[1] => 16
+        }
+      )
+    end
+
+    it 'correctly distributes workers for 3 queues with uneven loads' do
+      95.times do |n|
+        FirstJobBalancerTest.new.perform_async('first string', n)
+        SecondJobBalancerTest.new.perform_async('second string', n)
+      end
+
+      110.times do |n|
+        ThirdJobBalancerTest.new.perform_async('third string', n)
+      end
+
+      wb = Workerholic::WorkerBalancer.new(workers: workers, auto: true)
+
+      wb.auto_balanced_workers_distribution
+
+      expect(wb.current_workers_count_per_queue).to eq(
+        {
+          TESTED_QUEUES[0] => 8,
+          TESTED_QUEUES[1] => 8,
+          TESTED_QUEUES[2] => 9
+        }
+      )
+    end
+
+    it 'correctly distributes workers for 4 queues with uneven loads' do
+      100.times do |n|
+        FirstJobBalancerTest.new.perform_async('first string', n)
+        SecondJobBalancerTest.new.perform_async('second string', n)
+      end
+
+      200.times do |n|
+        ThirdJobBalancerTest.new.perform_async('third string', n)
+        FourthJobBalancerTest.new.perform_async('fourth string', n)
+      end
+      FourthJobBalancerTest.new.perform_async('fourth string', 201)
+
+      wb = Workerholic::WorkerBalancer.new(workers: workers, auto: true)
+
+      wb.auto_balanced_workers_distribution
+
+      expect(wb.current_workers_count_per_queue).to eq(
+        {
+          TESTED_QUEUES[0] => 4,
+          TESTED_QUEUES[1] => 4,
+          TESTED_QUEUES[2] => 8,
+          TESTED_QUEUES[3] => 9
+        }
+      )
+    end
+  end
+
+  context 'evenly-balancing workers distribution' do
+    it 'does not throw an error when there are no queues' do
+      wb = Workerholic::WorkerBalancer.new(workers: workers, auto: true)
+
+      wb.evenly_balanced_workers_distribution
+
+      expect(wb.current_workers_count_per_queue).to eq({})
+    end
+
+    it 'correctly distributes workers for 1 queue' do
+      100.times do |n|
+        FirstJobBalancerTest.new.perform_async('first string', n)
+      end
+      wb = Workerholic::WorkerBalancer.new(workers: workers, auto: true)
+
+      wb.evenly_balanced_workers_distribution
+
+      expect(wb.current_workers_count_per_queue).to eq({ TESTED_QUEUES[0] => 25 })
+    end
+
+    it 'correctly distributes workers for 2 queues with equivalent loads' do
+      100.times do |n|
+        FirstJobBalancerTest.new.perform_async('first string', n)
+        SecondJobBalancerTest.new.perform_async('second string', n)
+      end
+      wb = Workerholic::WorkerBalancer.new(workers: workers, auto: true)
+
+      wb.evenly_balanced_workers_distribution
+
+      expect(wb.current_workers_count_per_queue).to eq(
+        {
+          TESTED_QUEUES[0] => 12,
+          TESTED_QUEUES[1] => 13
+        }
+      )
+    end
+
+    it 'correctly distributes workers for 2 queues with uneven loads' do
+      100.times do |n|
+        FirstJobBalancerTest.new.perform_async('first string', n)
+      end
+
+      200.times do |n|
+        SecondJobBalancerTest.new.perform_async('second string', n)
+      end
+
+      wb = Workerholic::WorkerBalancer.new(workers: workers, auto: true)
+
+      wb.evenly_balanced_workers_distribution
+
+      expect(wb.current_workers_count_per_queue).to eq(
+        {
+          TESTED_QUEUES[0] => 12,
+          TESTED_QUEUES[1] => 13
+        }
+      )
+    end
+
+    it 'correctly distributes workers for 3 queues with uneven loads' do
+      95.times do |n|
+        FirstJobBalancerTest.new.perform_async('first string', n)
+        SecondJobBalancerTest.new.perform_async('second string', n)
+      end
+
+      110.times do |n|
+        ThirdJobBalancerTest.new.perform_async('third string', n)
+      end
+
+      wb = Workerholic::WorkerBalancer.new(workers: workers, auto: true)
+
+      wb.evenly_balanced_workers_distribution
+
+      expect(wb.current_workers_count_per_queue).to eq(
+        {
+          TESTED_QUEUES[0] => 8,
+          TESTED_QUEUES[1] => 8,
+          TESTED_QUEUES[2] => 9
+        }
+      )
+    end
+
+    it 'correctly distributes workers for 4 queues with uneven loads' do
+      100.times do |n|
+        FirstJobBalancerTest.new.perform_async('first string', n)
+        SecondJobBalancerTest.new.perform_async('second string', n)
+      end
+
+      200.times do |n|
+        ThirdJobBalancerTest.new.perform_async('third string', n)
+        FourthJobBalancerTest.new.perform_async('fourth string', n)
+      end
+      FourthJobBalancerTest.new.perform_async('fourth string', 201)
+
+      wb = Workerholic::WorkerBalancer.new(workers: workers, auto: true)
+
+      wb.evenly_balanced_workers_distribution
+
+      expect(wb.current_workers_count_per_queue).to eq(
+        {
+          TESTED_QUEUES[0] => 6,
+          TESTED_QUEUES[1] => 6,
+          TESTED_QUEUES[2] => 6,
+          TESTED_QUEUES[3] => 7
+        }
+      )
+    end
+  end
 end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: workerholic
 version: !ruby/object:Gem::Version
-  version: 0.0.23
+  version: 0.1.0
 platform: ruby
 authors:
 - Antoine Leclercq
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-11 00:00:00.000000000 Z
+date: 2017-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -139,6 +139,7 @@ files:
 - lib/workerholic/storage.rb
 - lib/workerholic/version.rb
 - lib/workerholic/web/application.rb
+- lib/workerholic/web/public/images/workerholic_logo.png
 - lib/workerholic/web/public/javascripts/application.js
 - lib/workerholic/web/public/stylesheets/application.css
 - lib/workerholic/web/public/stylesheets/whitespace-reset.css
@@ -152,7 +153,6 @@ files:
 - lib/workerholic/web/views/workers.erb
 - lib/workerholic/worker.rb
 - lib/workerholic/worker_balancer.rb
-- logos.png
 - spec/helpers/helper_methods.rb
 - spec/helpers/job_tests.rb
 - spec/integration/dequeuing_and_job_processing_spec.rb