geary 0.0.1

data/spec/gearman/client_spec.rb

@@ -0,0 +1,36 @@
+require 'gearman/client'
+require 'support/fake_server'
+require 'uri'
+
+module Gearman
+  describe Client do
+
+    let!(:address) { URI('gearman://127.0.0.1:4730') }
+    let!(:gearmand) { FakeServer.new(address) }
+
+    before do
+      gearmand.async.run
+      gearmand.wait :accept
+    end
+
+    after { gearmand.shutdown }
+
+    it 'submits background jobs' do
+      gearmand.respond_with(Packet::JOB_CREATED.new(['handle']))
+
+      expected_packet = Packet::SUBMIT_JOB_BG.new(
+        function_name: 'super_ability',
+        unique_id: 'UUID',
+        data: 'data'
+      )
+
+      client = Client.new(address)
+      client.generate_unique_id_with -> { 'UUID' }
+
+      client.submit_job_bg('super_ability', 'data')
+
+      expect(gearmand.packets_read.last).to eql(expected_packet)
+    end
+
+  end
+end

data/spec/gearman/connection_spec.rb

@@ -0,0 +1,67 @@
+require 'gearman/connection'
+require 'support/fake_server'
+require 'support/without_logging'
+require 'uri'
+
+module Gearman
+
+  describe Connection do
+    include WithoutLogging
+   
+    let!(:address) { URI('gearman://127.0.0.1:4730') }
+    let!(:server) { FakeServer.new(address) }
+
+    before do
+      server.async.run
+      server.wait :accept
+    end
+
+    after do
+      server.shutdown
+    end
+
+    it 'can write packets to a socket' do
+      connection = Connection.new(address)
+      connection.write(Gearman::Packet::WORK_COMPLETE.new(['*', '*']))
+
+      expect(server.packets_read.last).
+        to eql(Gearman::Packet::WORK_COMPLETE.new(['*', '*']))
+    end
+
+    it 'can read packets from a socket' do
+      server.respond_with(Gearman::Packet::NO_JOB.new)
+
+      connection = Connection.new(address)
+      connection.write(Gearman::Packet::GRAB_JOB.new)
+
+      expect(connection.next).to eql(Gearman::Packet::NO_JOB.new)
+    end
+
+    it 'can specify that it expects only certain types of packets' do
+      without_logging do
+        server.respond_with(Gearman::Packet::JOB_ASSIGN.new([1] * 3))
+
+        connection = Connection.new(address)
+        connection.write(Gearman::Packet::GRAB_JOB.new)
+
+        expect do
+          connection.next(Gearman::Packet::NO_JOB)
+        end.to raise_error(Connection::UnexpectedPacketError)
+      end
+    end
+
+    it 'will raise a ServerError if it reads an error packet' do
+      without_logging do
+        server.respond_with(Gearman::Packet::ERROR.new(["E", "T"]))
+
+        connection = Connection.new(address)
+        connection.write(Gearman::Packet::GRAB_JOB.new)
+
+        expect do
+          connection.next(Gearman::Packet::NO_JOB)
+        end.to raise_error(Connection::ServerError)
+      end
+    end
+
+  end
+end

data/spec/gearman/packet/sugar_spec.rb

@@ -0,0 +1,58 @@
+require 'gearman/packet/sugar'
+
+module Gearman
+  module Packet
+
+    describe Sugar do
+
+      it 'allows classes to create initializers which accept options' do
+        class_ = Class.new { extend Sugar ; takes(:foo, :bar) }
+        object = class_.new(foo: 'foo', bar: 'bar')
+
+        expect(object.foo).to eql('foo')
+        expect(object.bar).to eql('bar')
+        expect(object.arguments).to eql(['foo', 'bar'])
+      end
+
+      it 'allows classes to create initializers which accept positional arguments' do
+        class_ = Class.new { extend Sugar ; takes(:foo, :bar) }
+        object = class_.new(['foo', 'bar'])
+
+        expect(object.foo).to eql('foo')
+        expect(object.bar).to eql('bar')
+        expect(object.arguments).to eql(['foo', 'bar'])
+      end
+
+      it 'raises an ArgumentError if given something other than a Hash or an Array' do
+        class_ = Class.new { extend Sugar ; takes(:foo, :bar) }
+
+        expect do
+          object = class_.new(1)
+        end.to raise_error(ArgumentError)
+      end
+
+      it 'allows classes to set "numbers" for their instances' do
+        class_ = Class.new { extend Sugar ; number 1 }
+        object = class_.new
+
+        expect(object.number).to eql(1)
+      end
+
+      it 'can create new packet types with ease' do
+        type = Sugar.type 'CanDo', takes: [:function_name], number: 1
+
+        expect(type.new(['foo']).function_name).to eql('foo')
+        expect(type.new(function_name: 'foo').function_name).to eql('foo')
+        expect(type.new(function_name: 'foo').number).to eql(1)
+      end
+
+      it 'creates packets with value equality' do
+        type = Sugar.type 'CanDo', takes: [:function_name], number: 1
+
+        expect(type.new(['foo'])).to eql(type.new(['foo']))
+      end
+
+    end
+
+  end
+end

data/spec/gearman/packet_spec.rb

@@ -0,0 +1,22 @@
+require 'gearman/packet'
+
+module Gearman
+  describe Packet do
+
+    before do
+      Packet::Repository.new
+    end
+
+    it 'contains a bunch of packet types' do
+      %w(CAN_DO PRE_SLEEP NOOP GRAB_JOB NO_JOB JOB_ASSIGN
+      WORK_COMPLETE WORK_EXCEPTION).each do |type|
+        type = Gearman::Packet.const_get(type)
+        arguments = type.const_get('ARGUMENTS').map { 'foo ' }
+
+        expect do
+          type.new(arguments)
+        end.to_not raise_error
+      end
+    end
+  end
+end

data/spec/gearman/worker_spec.rb

@@ -0,0 +1,68 @@
+require 'gearman/worker'
+require 'support/actor_double'
+
+module Gearman
+
+  class FakeConnection
+    include Celluloid
+  end
+
+  describe Worker do
+    include ActorDouble
+
+    let!(:connection) { actor_double }
+
+    it 'expects a NOOP after it sends PRE_SLEEP' do
+      connection.stub(:write)
+      connection.should_receive(:next).with(Packet::NOOP)
+
+      worker = Worker.new('gearman://localhost:4730')
+      worker.configure_connection ->(address) { connection }
+
+      worker.pre_sleep
+    end
+
+    it 'expects either a JOB_ASSIGN or a NO_JOB when it grabs a job' do
+      connection.stub(:write)
+      connection.should_receive(:next).with(Packet::JOB_ASSIGN, Packet::NO_JOB)
+
+      worker = Worker.new('gearman://localhost:4730')
+      worker.configure_connection ->(address) { connection }
+
+      worker.grab_job
+    end
+
+    it 'sends WORK_EXCEPTION' do
+      work_exception = Packet::WORK_EXCEPTION.new(handle: 'h', data: 'd')
+      connection.should_receive(:write).with(work_exception)
+
+      worker = Worker.new('gearman://localhost:4730')
+      worker.configure_connection ->(address) { connection }
+
+      worker.work_exception('h', 'd')
+    end
+
+    it 'sends WORK_COMPLETE' do
+      work_complete = Packet::WORK_COMPLETE.new(handle: 'h', data: 'd')
+      connection.should_receive(:write).with(work_complete)
+
+      worker = Worker.new('gearman://localhost:4730')
+      worker.configure_connection ->(address) { connection }
+
+      worker.work_complete('h', 'd')
+    end
+
+    it 'sends CAN_DO' do
+      can_do = Packet::CAN_DO.new(function_name: 'ability')
+
+      connection.should_receive(:write).with(can_do)
+
+      worker = Worker.new('gearman://localhost:4730')
+      worker.configure_connection ->(address) { connection }
+
+      worker.can_do('ability')
+    end
+
+  end
+
+end

data/spec/geary/cli_spec.rb

@@ -0,0 +1,40 @@
+require 'geary/cli' 
+
+require 'thread'
+require 'timeout'
+
+module Geary
+  describe CLI do
+
+    it 'shuts down when sent TERM' do
+      kernel = double('kernel')
+      kernel.should_receive(:exit)
+      argv = ['-c 0']
+      cli = CLI.new(argv, STDOUT, STDERR, kernel)
+
+      t = Thread.new { cli.execute! }
+      t.abort_on_exception = true
+
+      cli.external_signal_queue.puts('TERM')
+
+      Timeout.timeout(1, StandardError) { t.value } rescue nil
+    end
+
+    it 'shuts down when sent INT' do
+      kernel = double('kernel')
+      kernel.should_receive(:exit)
+
+      argv = ['-c 0']
+      cli = CLI.new(argv, STDOUT, STDERR, kernel)
+
+      t = Thread.new { cli.execute! }
+      t.abort_on_exception = true
+
+      IO.select([], [cli.external_signal_queue])
+      cli.external_signal_queue.puts('INT')
+
+      Timeout.timeout(1, StandardError) { t.value } rescue nil
+    end
+
+  end
+end

data/spec/geary/manager_spec.rb

@@ -0,0 +1,123 @@
+require 'gearmand_control'
+
+require 'geary/configuration'
+require 'geary/manager'
+
+require 'support/fake_performer'
+require 'support/with_tolerance'
+require 'support/without_logging'
+
+module Geary
+
+  describe Manager do
+    include WithTolerance
+    include WithoutLogging
+
+    let(:configuration) do
+      configuration = Configuration.new(
+        server_addresses: ['gearman://localhost:4730'],
+        concurrency: 2
+      )
+    end
+
+    describe 'starting the manager' do
+
+      it 'establishes a link to managed performers' do
+        manager = Manager.new(configuration: configuration,
+                              performer_type: FakePerformer)
+        manager.start
+
+        expect(manager.links.count).to eql(2)
+      end
+
+      it 'starts each managed performer' do
+        manager = Manager.new(configuration: configuration,
+                              performer_type: FakePerformer)
+        manager.start
+
+        expect(manager.links.all?(&:started?)).to be_true
+        expect(manager.links.map(&:server_address).uniq).
+          to eql(configuration.server_addresses)
+      end
+
+    end
+
+    describe 'performer supervision' do
+
+      it 'restarts performers when they die' do
+        without_logging do
+          manager = Manager.new(configuration: configuration,
+                                performer_type: FakePerformer)
+          manager.start
+
+          imminently_dead_performers = manager.performers
+          imminently_dead_performers.map(&:async).each(&:die)
+
+          with_tolerance do
+            expect(imminently_dead_performers.count(&:alive?)).to eql(0)
+          end
+
+          with_tolerance do
+            expect(manager.links.count).to eql(2)
+          end
+        end
+      end
+
+      it 'forgets performers if they die without a reason' do
+        without_logging do
+          manager = Manager.new(configuration: configuration,
+                                performer_type: FakePerformer)
+          manager.start
+
+          forgettable_performers = manager.performers
+          forgettable_performers.map(&:async).each(&:die_quietly)
+
+          with_tolerance do
+            expect(forgettable_performers.count(&:alive?)).to eql(0)
+          end
+
+          with_tolerance do
+            expect(manager.links.count).to eql(0)
+          end
+        end
+      end
+
+    end
+
+    describe 'ceasing management' do
+
+      it 'terminates linked performers' do
+        manager = Manager.new(configuration: configuration,
+                              performer_type: FakePerformer)
+        manager.start
+
+        performers = manager.performers
+
+        expect do
+          manager.stop
+        end.to change { performers.count(&:alive?) }.from(2).to(0)
+      end
+
+      it 'unlinks linked performers' do
+        manager = Manager.new(configuration: configuration,
+                              performer_type: FakePerformer)
+        manager.start
+
+        expect do
+          manager.stop
+        end.to change { manager.links.count }.from(2).to(0)
+      end
+
+      it 'signals that it has stopped' do
+        manager = Manager.new(configuration: configuration,
+                              performer_type: FakePerformer)
+        manager.async.start
+        manager.async.stop
+
+        expect(manager.wait :done).to be_nil
+      end
+
+    end
+
+  end
+end

data/spec/geary/option_parser_spec.rb

@@ -0,0 +1,17 @@
+require 'geary/option_parser'
+
+module Geary
+  describe OptionParser do
+
+    it 'understands comma-delimited servers to mean multiple servers' do
+      args = ['-s', 'gearman://localhost:4730,gearman://localhost:4731']
+      parser = OptionParser.new
+
+      configuration = parser.parse(args)
+
+      expect(configuration.server_addresses.map(&:to_s)).
+        to eql(['gearman://localhost:4730', 'gearman://localhost:4731'])
+    end
+
+  end
+end

data/spec/geary/performer_spec.rb

@@ -0,0 +1,128 @@
+require 'geary/performer'
+require 'support/actor_double'
+require 'support/without_logging'
+require 'uri'
+
+module Geary
+  describe Performer do
+    include ActorDouble
+    include WithoutLogging
+
+    let(:address) do
+      URI('gearman://localhost:4730')
+    end
+
+    let(:gearman) { actor_double }
+
+    it 'registers its ability with Gearman' do
+      gearman.stub(:grab_job)
+      gearman.should_receive(:can_do)
+
+      performer = Performer.new(address)
+      performer.configure_connection ->(address) { gearman }
+
+      performer.start
+    end
+
+    it 'tries to pop a job off the queue' do
+      gearman.stub(:can_do)
+      gearman.should_receive(:grab_job)
+
+      performer = Performer.new(address)
+      performer.configure_connection ->(address) { gearman }
+
+      performer.start
+    end
+
+    it 'sleeps if it gets a NO_JOB' do
+      gearman.stub(:can_do)
+      gearman.stub(:grab_job).and_return(Gearman::Packet::NO_JOB.new, nil)
+      gearman.should_receive(:pre_sleep)
+
+      performer = Performer.new(address)
+      performer.configure_connection ->(address) { gearman }
+
+      performer.start
+    end
+
+    it 'performs the job if it gets a JOB_ASSIGN' do
+      worker_class = Class.new { }
+      worker = worker_class.any_instance
+
+      Object.const_set('A', worker_class)
+
+      job = JSON.dump({
+        class: 'A',
+        args: ['a']
+      })
+
+      job_assign = Gearman::Packet::JOB_ASSIGN.new(['h', 'f', job])
+
+      gearman.stub(:can_do)
+      gearman.stub(:grab_job).and_return(job_assign, nil)
+      gearman.stub(:work_complete)
+
+      worker.should_receive(:perform).with('a')
+
+      performer = Performer.new(address)
+      performer.configure_connection ->(address) { gearman }
+
+      performer.start
+    end
+
+    it 'sends the result of a job to Gearman' do
+      worker_class = Class.new { }
+      worker = worker_class.any_instance
+      worker.stub(:perform) { 'result' }
+
+      Object.const_set('B', worker_class)
+
+      job = JSON.dump({
+        class: 'B',
+        args: ['a']
+      })
+
+      async_proxy = double('gearman.async')
+      job_assign = Gearman::Packet::JOB_ASSIGN.new(['h', 'f', job])
+
+      gearman.stub(:can_do)
+      gearman.stub(:grab_job).and_return(job_assign, nil)
+      gearman.stub(:async) { async_proxy }
+      async_proxy.should_receive(:work_complete).with('h', 'result')
+
+      performer = Performer.new(address)
+      performer.configure_connection ->(address) { gearman }
+
+      performer.start
+    end
+
+    it 'sends a WORK_EXCEPTION to Gearman if the job raises' do
+      worker_class = Class.new { }
+      worker = worker_class.any_instance
+      worker.stub(:perform).and_raise RuntimeError, "ack!"
+
+      Object.const_set('C', worker_class)
+
+      job = JSON.dump({
+        class: 'C',
+        args: ['a']
+      })
+
+      async_proxy = double('gearman.async')
+      job_assign = Gearman::Packet::JOB_ASSIGN.new(['h', 'f', job])
+
+      gearman.stub(:can_do)
+      gearman.stub(:grab_job).and_return(job_assign, nil)
+      gearman.stub(:async) { async_proxy }
+      async_proxy.should_receive(:work_exception).with('h', 'ack!')
+
+      performer = Performer.new(address)
+      performer.configure_connection ->(address) { gearman }
+
+      performer.start
+    end
+
+    it 'can repair its connection to Gearman'
+
+  end
+end