did_workling 0.0.1

data/lib/workling/return/store/starling_return_store.rb

@@ -0,0 +1,31 @@
+require 'workling/return/store/base'
+require 'workling/clients/memcache_queue_client'
+
+#
+#  Recommended Return Store if you are using the Starling Runner. This
+#  Simply sets and gets values against queues. 'key' is the name of the respective Queue. 
+#
+module Workling
+  module Return
+    module Store
+      class StarlingReturnStore < Base
+        cattr_accessor :client
+        
+        def initialize
+          self.client = Workling::Clients::MemcacheQueueClient.new
+          self.client.connect
+        end
+        
+        # set a value in the queue 'key'. 
+        def set(key, value)
+          self.class.client.set(key, value)
+        end
+        
+        # get a value from starling queue 'key'.
+        def get(key)
+          self.class.client.get(key)
+        end
+      end
+    end
+  end
+end

data/lib/workling/routing/base.rb

@@ -0,0 +1,13 @@
+#
+#  Base Class for Routing. Routing takes the worker method TestWorker#something, 
+#  and serializes the signature in some way. 
+#
+module Workling
+  module Routing
+    class Base < Hash
+      def method_name
+        raise Exception.new("method_name not implemented.")
+      end
+    end
+  end
+end

data/lib/workling/routing/class_and_method_routing.rb

@@ -0,0 +1,55 @@
+require 'workling/routing/base'
+
+#
+#  Holds a hash of routes. Each Worker method has a corresponding hash entry after building. 
+#
+module Workling
+  module Routing
+    class ClassAndMethodRouting < Base
+          
+      # initializes and builds routing hash. 
+      def initialize
+        super
+
+        build
+      end
+      
+      # returns the worker method name, given the routing string. 
+      def method_name(queue)
+        queue.split("__").last
+      end
+      
+      # returns the routing string, given a class and method. delegating. 
+      def queue_for(clazz, method)
+        ClassAndMethodRouting.queue_for(clazz, method)
+      end
+              
+      # returns the routing string, given a class and method.
+      def self.queue_for(clazz, method)
+        "#{ clazz.to_s.tableize }/#{ method }".split("/").join("__") # Don't split with : because it messes up memcache stats
+      end
+      
+      # returns all routed
+      def queue_names
+        self.keys
+      end
+      
+      # dare you to remove this! go on! 
+      def queue_names_routing_class(clazz)
+        self.select { |x, y|  y.is_a?(clazz) }.map { |x, y| x }
+      end
+      
+      private
+        def build
+          Workling::Discovery.discovered.each do |clazz|
+            methods = clazz.instance_methods(false)
+            methods.each do |method|
+              next if method == 'create'  # Skip the create method
+              queue =  queue_for(clazz, method)
+              self[queue] = clazz.new
+            end   
+          end     
+        end       
+    end
+  end
+end

data/test/class_and_method_routing_test.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "class and method routing" do
+  specify "should create a queue called utils:echo for a Util class that subclasses worker and has the method echo" do
+    routing = Workling::Routing::ClassAndMethodRouting.new  
+    routing['utils__echo'].class.to_s.should.equal "Util"
+  end
+  
+  specify "should create a queue called analytics:invites:sent for an Analytics::Invites class that subclasses worker and has the method sent" do
+    routing = Workling::Routing::ClassAndMethodRouting.new
+    routing['analytics__invites__sent'].class.to_s.should.equal "Analytics::Invites"
+  end
+  
+  specify "queue_names_routing_class should return all queue names associated with a class" do
+    routing = Workling::Routing::ClassAndMethodRouting.new
+    routing.queue_names_routing_class(Util).should.include 'utils__echo'
+  end
+end

data/test/clients/memory_queue_client.rb

@@ -0,0 +1,36 @@
+require 'workling/clients/base'
+
+module Workling
+  module Clients
+    class MemoryQueueClient < Workling::Clients::Base
+      
+      def initialize
+        @subscribers ||= {}
+        @queues ||= {}
+      end
+      
+      # collects the worker blocks in a hash
+      def subscribe(work_type, &block)
+        @subscribers[work_type] = block
+      end
+      
+      # immediately invokes the required worker block
+      def request(work_type, arguments)
+        if subscription = @subscribers[work_type]
+          subscription.call(arguments)
+        else
+          @queues[work_type] ||= []
+          @queues[work_type] << arguments
+        end
+      end
+      
+      def retrieve(work_type)
+        queue = @queues[work_type]
+        queue.pop if queue
+      end
+      
+      def connect; true; end
+      def close; true; end
+    end
+  end
+end

data/test/discovery_test.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "discovery" do
+  specify "should discover the Util workling, since it subclasses Workling::Base and is on the configured Workling load path." do
+    discovered = Workling::Discovery.discovered
+    discovered.map(&:to_s).should.include "Util"
+  end
+  
+  specify "should not discover non-worker classes" do
+    discovered = Workling::Discovery.discovered
+    discovered.all? { |clazz| clazz.superclass == Workling::Base }.should.blaming("some discovered classes were not workers").equal true
+  end
+end

data/test/invoker_basic_poller_test.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "the invoker 'basic poller'" do
+  setup do
+    routing = Workling::Routing::ClassAndMethodRouting.new
+    @client = Workling::Clients::MemoryQueueClient.new
+    @client.connect
+    @invoker = Workling::Remote::Invokers::BasicPoller.new(routing, @client.class)
+  end
+  
+  specify "should not explode when listen is called, and stop nicely when stop is called. " do
+    connection = mock()
+    connection.expects(:active?).at_least_once.returns(true)
+    ActiveRecord::Base.expects(:connection).at_least_once.returns(connection)
+    
+    client = mock()
+    client.expects(:retrieve).at_least_once.returns("hi")
+    client.expects(:connect).at_least_once.returns(true)
+    client.expects(:close).at_least_once.returns(true)
+    Workling::Clients::MemoryQueueClient.expects(:new).at_least_once.returns(client)
+    
+    # Don't take longer than 10 seconds to shut this down. 
+    Timeout::timeout(10) do
+      listener = Thread.new { @invoker.listen }
+      @invoker.stop
+      listener.join
+    end
+  end
+end

data/test/invoker_eventmachine_subscription_test.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "the invoker 'eventmachine subscription'" do
+  setup do
+    routing = Workling::Routing::ClassAndMethodRouting.new
+    @client_class = Workling::Clients::MemoryQueueClient
+    @client = @client_class.new
+    @client.connect
+    @invoker = Workling::Remote::Invokers::EventmachineSubscriber.new(routing, @client_class)
+  end
+  
+  specify "should invoke Util.echo with the arg 'hello' if the string 'hello' is set onto the queue utils__echo" do
+
+    # make sure all new instances point to the same client. that way, state is shared
+    Workling::Clients::MemoryQueueClient.expects(:new).at_least_once.returns @client
+    Util.any_instance.expects(:echo).once.with({ :message => "hello" })
+    
+    # Don't take longer than 10 seconds to shut this down. 
+    Timeout::timeout(10) do
+      listener = Thread.new { @invoker.listen }
+      @client.request("utils__echo", { :message => "hello" })
+      @invoker.stop
+      listener.join
+    end
+  end
+end

data/test/invoker_threaded_poller_test.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "the invoker 'threaded poller'" do
+  setup do
+    routing = Workling::Routing::ClassAndMethodRouting.new
+    @client = Workling::Clients::MemoryQueueClient.new
+    @client.connect
+    @invoker = Workling::Remote::Invokers::ThreadedPoller.new(routing, @client.class)
+  end
+  
+  specify "should invoke Util.echo with the arg 'hello' if the string 'hello' is set onto the queue utils__echo" do
+    Util.any_instance.stubs(:echo).with("hello")
+    @client.request("utils__echo", "hello")
+    @invoker.dispatch!(@client, Util)
+  end
+  
+  specify "should not explode when listen is called, and stop nicely when stop is called. " do
+    connection = mock()
+    connection.expects(:active?).at_least_once.returns(true)
+    ActiveRecord::Base.expects(:connection).at_least_once.returns(connection)
+    
+    client = mock()
+    client.expects(:retrieve).at_least_once.returns("hi")
+    client.expects(:connect).at_least_once.returns(true)
+    Workling::Clients::MemoryQueueClient.expects(:new).at_least_once.returns(client)
+    
+    # Don't take longer than 10 seconds to shut this down. 
+    Timeout::timeout(10) do
+      listener = Thread.new { @invoker.listen }
+      @invoker.stop
+      listener.join
+    end
+  end
+end

data/test/memcachequeue_client_test.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "The memcachequeue client" do
+  specify "should be able to connect to multiple queue instances" do
+    Workling.send :class_variable_set, "@@config", { :listens_on => "localhost:12345, 127.0.0.1:12346", :memcache_options => { :namespace => "myapp_development" } }
+    client = Workling::Clients::MemcacheQueueClient.new
+    client.connect
+    
+    client.queueserver_urls.should.equal ["localhost:12345", "127.0.0.1:12346"]
+    client.connection.servers.first.host.should == "localhost"
+    client.connection.servers.first.port.should == 12345    
+    client.connection.servers[1].host.should == "127.0.0.1"
+    client.connection.servers[1].port.should == 12346 
+    client.connection.namespace.should.equal "myapp_development"
+  end
+  
+  specify "should load it's config as well as any given MemCache options from RAILS_ENV/config/workling.yml" do
+    Workling.send :class_variable_set, "@@config", { :listens_on => "localhost:12345", :memcache_options => { :namespace => "myapp_development" } }
+    client = Workling::Clients::MemcacheQueueClient.new
+    client.connect
+    
+    client.queueserver_urls.should.equal ["localhost:12345"]
+    client.connection.servers.first.host.should == "localhost"
+    client.connection.servers.first.port.should == 12345    
+    client.connection.namespace.should.equal "myapp_development"
+  end
+  
+  
+  specify "should load it's config correctly if no memcache options are given" do
+    Workling.send :class_variable_set, "@@config", { :listens_on => "localhost:12345" }
+    client = Workling::Clients::MemcacheQueueClient.new
+    client.connect
+
+    client.queueserver_urls.should.equal ["localhost:12345"]
+  end  
+end

data/test/memory_return_store_test.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "the memory return store" do
+  specify "should be able to store a value with a key, and then retrieve that same value with the same key." do
+    store = Workling::Return::Store::MemoryReturnStore.new
+    key, value = :gender, :undecided
+    store.set(key, value)
+    store.get(key).should.equal(value)
+  end
+  
+  specify "should delete values in the store once they have been get()tted." do
+    store = Workling::Return::Store::MemoryReturnStore.new
+    key, value = :gender, :undecided
+    store.set(key, value)
+    store.get(key)
+    store.get(key).should.equal nil
+  end
+  
+  specify "should return nothing for a key that is not in the store" do
+    store = Workling::Return::Store::MemoryReturnStore.new
+    store.get(:bollocks).should.equal nil
+  end
+end

data/test/mocks/client.rb

@@ -0,0 +1,9 @@
+require 'workling/clients/base'
+
+module Workling
+  module Clients
+    class MemcacheQueueClient < Workling::Clients::Base
+      def raise_unless_connected!; end
+    end
+  end
+end

data/test/mocks/logger.rb

@@ -0,0 +1,5 @@
+class Logger
+  def initialize(*args); end
+  def log(str); end
+  def error(str); end
+end

data/test/mocks/spawn.rb

@@ -0,0 +1,5 @@
+module Spawn
+  def spawn(*args)
+    yield
+  end
+end

data/test/not_remote_runner_test.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "The not remote runner" do  
+  specify "should swallow exceptions raised in the workling" do
+    old_dispatcher = Workling::Remote.dispatcher
+    
+    Workling::Remote.dispatcher = Workling::Remote::Runners::NotRemoteRunner.new
+    Workling::Remote.run(:util, :faulty)
+    Workling::Remote.dispatcher = old_dispatcher # set back to whence we came
+  end
+end

data/test/remote_runner_test.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+context "the remote runner" do
+  specify "should be able to invoke a task on a worker" do
+    Util.any_instance.stubs(:echo).with("hello")
+    Workling::Remote.run(:util, :echo, "hello")
+  end
+  
+  specify "should invoke the dispatcher set up in Workling::Remote.dispatcher" do
+    clazz, method, options = :util, :echo, { :message => "somebody_came@along.com" }
+    old_dispatcher = Workling::Remote.dispatcher
+    dispatcher = mock
+    dispatcher.expects(:run).with(clazz, method, options)
+    Workling::Remote.dispatcher = dispatcher
+    Workling::Remote.run(clazz, method, options)
+    Workling::Remote.dispatcher = old_dispatcher # set back to whence we came
+  end
+  
+  specify "should, when being tested, use the default remote runner by when no runner was explicitly set. " do
+    Workling::Remote.dispatcher.class.should.equal Workling.default_runner.class
+  end
+  
+  specify "should raise a Workling::WorklingNotFoundError if it is invoked with a worker key that cannot be constantized" do
+    should.raise Workling::WorklingNotFoundError do
+      Workling::Remote.run(:quatsch_mit_sosse, :fiddle_di_liddle)
+    end
+  end
+  
+  specify "should raise a Workling::WorklingNotFoundError if it is invoked with a valid worker key but the method is not defined on that worker" do
+    dispatcher = Workling::Remote.dispatcher
+    Workling::Remote.dispatcher = Workling::Remote::Runners::ThreadRunner.new # simulates a remote runner (workling in another context)
+    
+    should.raise Workling::WorklingNotFoundError do
+      Workling::Remote.run(:util, :sau_sack)
+    end
+    
+    Workling::Remote.dispatcher = dispatcher
+  end
+  
+  specify "should invoke work when called in this way: YourWorkling.asynch_your_method(options)" do
+    Util.any_instance.expects(:echo).once
+    Util.asynch_echo
+  end
+  
+  specify "should invoke work with the arguments intact when called in this way: YourWorkling.asynch_your_method(options)" do
+    stuffing = { :description => "toasted breadcrumbs with dill" }
+    Util.any_instance.expects(:stuffing).with(stuffing).once
+    Util.asynch_stuffing(stuffing)
+  end
+end

data/test/return_store_test.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "The return store" do
+  specify "should set a value on the current store when invoked like this: Workling::Return::Store.set(:key, 'value')" do
+    Workling::Return::Store.set(:key, :value)
+    Workling::Return::Store.get(:key).should.equal :value
+  end
+  
+  specify "should get a value on the current store when invoked like this: Workling::Return::Store.get(:key)" do
+    Workling::Return::Store.set(:key, :value)
+    Workling::Return::Store.get(:key).should.equal :value 
+  end
+  
+  specify "should set a value on the current store when invoked like this: Workling.return.set(:key, 'value')" do
+    Workling.return.set(:key, :value)
+    Workling.return.get(:key).should.equal :value
+  end
+end

data/test/runners/thread_runner.rb

@@ -0,0 +1,22 @@
+require 'workling/remote/runners/base'
+
+#
+#  Spawns a Thread. Used for Tests only, to simulate a remote runner more realistically. 
+#
+module Workling
+  module Remote
+    module Runners
+      class ThreadRunner < Workling::Remote::Runners::Base
+        
+        # spawns a thread. 
+        def run(clazz, method, options = {})
+          Thread.new {
+            dispatch!(clazz, method, options) 
+          }
+                    
+          return nil
+        end
+      end
+    end
+  end
+end