employer 0.0.1 → 0.1

data/lib/employer/employees/threading_employee.rb

@@ -0,0 +1,38 @@
+require_relative "abstract_employee"
+
+module Employer
+  module Employees
+    class ThreadingEmployee < AbstractEmployee
+      def work(job)
+        super
+        @work_state = :busy
+
+        @thread = Thread.new do
+          begin
+            perform_job
+            @work_state = :complete
+          rescue => exception
+          ensure
+            @work_state = :failed if @work_state == :busy
+          end
+        end
+      end
+
+      def free
+        super
+        @thread = nil
+      end
+
+      def work_state(wait = false)
+        @thread.join if wait && @thread
+        return @work_state
+      end
+
+      def force_work_stop
+        return if free?
+        @thread.kill
+        @work_state = :failed
+      end
+    end
+  end
+end

data/lib/employer/errors.rb

@@ -0,0 +1,5 @@
+require_relative "errors/error"
+require_relative "errors/employee_busy"
+require_relative "errors/job_class_mismatch"
+require_relative "errors/no_employee_free"
+require_relative "errors/pipeline_backend_required"

data/lib/employer/errors/employee_busy.rb

@@ -0,0 +1,6 @@
+module Employer
+  module Errors
+    class EmployeeBusy < Error
+    end
+  end
+end

data/lib/employer/errors/error.rb

@@ -0,0 +1,6 @@
+module Employer
+  module Errors
+    class Error < ::StandardError
+    end
+  end
+end

data/lib/employer/errors/job_class_mismatch.rb

@@ -0,0 +1,6 @@
+module Employer
+  module Errors
+    class JobClassMismatch < Error
+    end
+  end
+end

data/lib/employer/errors/no_employee_free.rb

@@ -0,0 +1,6 @@
+module Employer
+  module Errors
+    class NoEmployeeFree < Error
+    end
+  end
+end

data/lib/employer/errors/pipeline_backend_required.rb

@@ -0,0 +1,6 @@
+module Employer
+  module Errors
+    class PipelineBackendRequired < Error
+    end
+  end
+end

data/lib/employer/job.rb

@@ -0,0 +1,55 @@
+require_relative "errors"
+
+module Employer
+  module Job
+    attr_accessor :id
+
+    module ClassMethods
+      def attribute(name)
+        name = name.to_sym
+        unless attribute_names.include?(name)
+          attribute_names << name
+          attr_accessor name
+        end
+      end
+
+      def attribute_names
+        @attribute_names ||= []
+      end
+
+      def deserialize(serialized_job)
+        raise Employer::Errors::JobClassMismatch unless serialized_job[:class] == self.name
+        job = new
+        job.id = serialized_job[:id]
+        serialized_job[:attributes].each_pair do |attribute, value|
+          job.public_send("#{attribute}=", value)
+        end
+        job
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def attribute_names
+      self.class.attribute_names
+    end
+
+    def try_again?
+      false
+    end
+
+    def serialize
+      {
+        id: id,
+        class: self.class.name,
+        attributes: Hash[
+          attribute_names.
+            reject { |name| self.send(name).nil? }.
+            map { |name| [name, self.send(name)] }
+        ]
+      }.reject { |key, value| value.nil? }
+    end
+  end
+end

data/lib/employer/pipeline.rb

@@ -0,0 +1,55 @@
+require_relative "errors"
+
+module Employer
+  class Pipeline
+    def backend=(backend)
+      @backend = backend
+    end
+
+    def backend
+      @backend
+    end
+
+    def enqueue(job)
+      raise Employer::Errors::PipelineBackendRequired if backend.nil?
+      serialized_job = job.serialize
+      backend.enqueue(serialized_job)
+    end
+
+    def dequeue
+      raise Employer::Errors::PipelineBackendRequired if backend.nil?
+      if serialized_job = backend.dequeue
+        job_class = constantize(serialized_job[:class])
+        job_class.deserialize(serialized_job)
+      end
+    end
+
+    def complete(job)
+      raise Employer::Errors::PipelineBackendRequired if backend.nil?
+      backend.complete(job)
+    end
+
+    def reset(job)
+      raise Employer::Errors::PipelineBackendRequired if backend.nil?
+      backend.reset(job)
+    end
+
+    def fail(job)
+      raise Employer::Errors::PipelineBackendRequired if backend.nil?
+      backend.fail(job)
+    end
+
+    private
+
+    def constantize(camel_cased_word)
+      names = camel_cased_word.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      constant = Object
+      names.each do |name|
+        constant = constant.const_defined?(name, false) ? constant.const_get(name) : constant.const_missing(name)
+      end
+      constant
+    end
+  end
+end

data/lib/employer/version.rb

@@ -1,3 +1,3 @@
 module Employer
-  VERSION = "0.0.1"
+  VERSION = "0.1"
 end

data/lib/employer/workshop.rb

@@ -0,0 +1,66 @@
+require_relative "errors"
+
+module Employer
+  class Workshop
+    def self.setup(config_code, skip_employees = false)
+      boss = Employer::Boss.new
+      pipeline = Employer::Pipeline.new
+      boss.pipeline = pipeline
+      workshop = new(boss, config_code, skip_employees)
+    end
+
+    def self.pipeline(filename)
+      workshop = setup(File.read(filename), true)
+      workshop.pipeline
+    end
+
+    def run
+      @boss.manage
+    end
+
+    def stop
+      @boss.stop_managing
+    end
+
+    def stop_now
+      @boss.stop_managing
+      @boss.stop_employees
+    end
+
+    def pipeline
+      @boss.pipeline
+    end
+
+    private
+
+    def forking_employees(number)
+      @forking_employees = number
+    end
+
+    def threading_employees(number)
+      @threading_employees = number
+    end
+
+    def pipeline_backend(backend)
+      @boss.pipeline.backend = backend
+    end
+
+    def initialize(boss, config_code, skip_employees)
+      @boss = boss
+      @forking_employees = 0
+      @threading_employees = 0
+
+      instance_eval(config_code)
+
+      unless skip_employees
+        @forking_employees.times do
+          @boss.allocate_employee(Employer::Employees::ForkingEmployee.new)
+        end
+
+        @threading_employees.times do
+          @boss.allocate_employee(Employer::Employees::ThreadingEmployee.new)
+        end
+      end
+    end
+  end
+end

data/spec/employer/boss_spec.rb

@@ -0,0 +1,254 @@
+require "employer/boss"
+
+describe Employer::Boss do
+  let(:pipeline) { double("Pipeline") }
+  let(:employee) { double("Employee") }
+  let(:free_employee) { double("Free employee", free?: true) }
+  let(:busy_employee) { double("Busy employee", free?: false) }
+  let(:boss) { Employer::Boss.new }
+
+  it "can be given a pipeline" do
+    boss.pipeline = pipeline
+    boss.pipeline.should eq(pipeline)
+  end
+
+  it "can be given employees" do
+    john = double
+    jane = double
+    boss.allocate_employee(john)
+    boss.allocate_employee(jane)
+    boss.employees.should eq([john, jane])
+  end
+
+  describe "#manage" do
+    it "delegates work and collects progress updates until stopped, and then wait on employees" do
+      boss.should_receive(:keep_going).and_return(true, true, false)
+      boss.should_receive(:delegate_work).twice
+      boss.should_receive(:progress_update).twice
+      boss.should_receive(:wait_on_employees)
+      boss.manage
+    end
+  end
+
+  describe "#stop_managing" do
+    it "sets keep_going to false" do
+      boss.keep_going.should eq(nil)
+      boss.stop_managing
+      boss.keep_going.should eq(false)
+    end
+  end
+
+  describe "#delegate_work" do
+    let(:job1) { double("Job 1") }
+    let(:job2) { double("Job 2") }
+    let(:employee1) { double("Employee 1") }
+    let(:employee2) { double("Employee 2") }
+    let(:employee3) { double("Employee 3") }
+
+    before(:each) do
+      boss.stub(:get_work).and_return(job1, job2, nil, nil)
+      boss.pipeline = pipeline
+    end
+
+    it "puts free employees to work while work is available" do
+      employee1_free = true
+      employee2_free = true
+      employee1.stub(:free?) { employee1_free }
+      employee2.stub(:free?) { employee2_free }
+      employee3.stub(:free?).and_return(false)
+      employee1.should_receive(:work).with(job1) { employee1_free = false }
+      employee2.should_receive(:work).with(job2) { employee2_free = false }
+      employee3.should_receive(:work).never
+      boss.allocate_employee(employee1)
+      boss.allocate_employee(employee2)
+      boss.allocate_employee(employee3)
+      boss.delegate_work
+    end
+
+    it "puts free employees to work" do
+      employee1_free = true
+      employee1.stub(:free?) { employee1_free }
+      employee1.should_receive(:work).with(job1) { employee1_free = false }
+      boss.allocate_employee(employee1)
+      boss.delegate_work
+
+      employee1_free = true
+      employee1.should_receive(:work).with(job2) { employee1_free = false }
+      boss.delegate_work
+
+      employee1_free = true
+      employee1.should_receive(:work).never
+      boss.delegate_work
+    end
+  end
+
+  describe "#get_work" do
+    before(:each) do
+      pipeline.stub(:dequeue).and_return(nil)
+      boss.pipeline = pipeline
+    end
+
+    it "increases sleep time each time it gets no job" do
+      boss.should_receive(:sleep).with(0.5).ordered
+      boss.get_work.should be_nil
+      boss.should_receive(:sleep).with(1).ordered
+      boss.get_work.should be_nil
+      boss.should_receive(:sleep).with(2.5).ordered
+      boss.get_work.should be_nil
+      boss.should_receive(:sleep).with(5).ordered
+      boss.get_work.should be_nil
+      boss.should_receive(:sleep).with(5).ordered
+      boss.get_work.should be_nil
+    end
+
+    it "increases resets sleep time when it gets a job" do
+      job = double("Job")
+      pipeline.stub(:dequeue).and_return(nil, nil, job, job)
+      boss.should_receive(:sleep).with(0.5).ordered
+      boss.get_work.should be_nil
+      boss.should_receive(:sleep).with(1).ordered
+      boss.get_work.should be_nil
+      boss.should_receive(:sleep).with(0.1).ordered
+      boss.get_work.should eq(job)
+      boss.should_receive(:sleep).with(0.1).ordered
+      boss.get_work.should eq(job)
+    end
+  end
+
+  describe "#update_job_status" do
+    before(:each) do
+      boss.pipeline = pipeline
+    end
+
+    let(:job) { double("Job") }
+    let(:employee) { employee = double("Employee", job: job) }
+
+    it "completes the job and frees the employee if employee reports job completed" do
+      employee.should_receive(:work_in_progress?).and_return(false)
+      employee.should_receive(:work_completed?).and_return(true)
+      employee.should_receive(:free)
+      pipeline.should_receive(:complete).with(job)
+      boss.update_job_status(employee)
+    end
+
+    it "fails the job and frees the employee if employee reports job failed, and the job may not be retried" do
+      employee.should_receive(:work_in_progress?).and_return(false)
+      employee.should_receive(:work_completed?).and_return(false)
+      employee.should_receive(:work_failed?).and_return(true)
+      employee.should_receive(:free)
+      job.should_receive(:try_again?).and_return(false)
+      pipeline.should_receive(:fail).with(job)
+      boss.update_job_status(employee)
+    end
+
+    it "resets the job and frees the employee if employee reports job failed, and the job may be retried" do
+      employee.should_receive(:work_in_progress?).and_return(false)
+      employee.should_receive(:work_completed?).and_return(false)
+      employee.should_receive(:work_failed?).and_return(true)
+      employee.should_receive(:free)
+      job.should_receive(:try_again?).and_return(true)
+      pipeline.should_receive(:reset).with(job)
+      boss.update_job_status(employee)
+    end
+
+    it "does nothing when the work is still in progress" do
+      employee.should_receive(:work_in_progress?).and_return(true)
+      boss.update_job_status(employee)
+    end
+  end
+
+  describe "#progess_update" do
+    it "gets progress updates from busy employees with #update_job_status" do
+      busy_employee = double("Busy employee", free?: false)
+      free_employee = double("Free employee", free?: true)
+      boss.allocate_employee(free_employee)
+      boss.allocate_employee(busy_employee)
+      boss.should_receive(:update_job_status).with(busy_employee)
+      boss.should_receive(:update_job_status).with(free_employee).never
+      boss.progress_update
+    end
+  end
+
+  describe "#wait_on_employees" do
+    it "will wait for all busy employees to complete their work, then perform a progress update" do
+      busy_employee = double("Busy employee", free?: false)
+      free_employee = double("Free employee", free?: true)
+      boss.allocate_employee(free_employee)
+      boss.allocate_employee(busy_employee)
+      busy_employee.should_receive(:wait_for_completion)
+      free_employee.should_receive(:wait_for_completion).never
+      boss.should_receive(:update_job_status).with(busy_employee)
+      boss.wait_on_employees
+    end
+  end
+
+  describe "#stop_employees" do
+    it "will force all employees to stop their work" do
+      busy_employee = double("Busy employee", free?: false).as_null_object
+      free_employee = double("Free employee", free?: true)
+      boss.allocate_employee(free_employee)
+      boss.allocate_employee(busy_employee)
+      busy_employee.should_receive(:stop_working)
+      busy_employee.should_receive(:free)
+      free_employee.should_receive(:stop_working).never
+      free_employee.should_receive(:free).never
+      boss.should_receive(:update_job_status).with(busy_employee)
+      boss.stop_employees
+    end
+  end
+
+  describe "#delegate_job" do
+    let(:job) { double("Job") }
+
+    it "will put a free employee to work on a job" do
+      employee.should_receive(:free?).and_return(true)
+      boss.allocate_employee(employee)
+      employee.should_receive(:work).with(job)
+      boss.delegate_job(job)
+    end
+
+    it "will raise when there is no free employee" do
+      expect { boss.delegate_job(job) }.to raise_error(Employer::Errors::NoEmployeeFree)
+    end
+  end
+
+  describe "#free_employee?" do
+    it "true if there is atleast one employee free" do
+      employee.should_receive(:free?).and_return(true)
+      boss.allocate_employee(employee)
+      boss.free_employee?.should be_true
+    end
+
+    it "false if there is no free employee" do
+      employee.should_receive(:free?).and_return(false)
+      boss.allocate_employee(employee)
+      boss.free_employee?.should be_false
+    end
+  end
+
+  describe "#busy_employees" do
+    it "returns the busy employees" do
+      boss.allocate_employee(busy_employee)
+      boss.allocate_employee(free_employee)
+      boss.busy_employees.should eq([busy_employee])
+    end
+
+    it "returns [] when there is are no busy employees" do
+      boss.allocate_employee(free_employee)
+      boss.busy_employees.should eq([])
+    end
+  end
+
+  describe "#free_employee" do
+    it "returns the first free employee" do
+      boss.allocate_employee(busy_employee)
+      boss.allocate_employee(free_employee)
+      boss.free_employee.should eq(free_employee)
+    end
+
+    it "returns nil when there is no free employee" do
+      boss.allocate_employee(busy_employee)
+      boss.free_employee.should be_nil
+    end
+  end
+end