elecnix-workling 0.4.2 → 0.4.9

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

@@ -1,42 +0,0 @@
-#
-#  Basic interface for getting and setting Data which needs to be passed between Workers and
-#  client code. 
-#
-module Workling
-  module Return
-    module Store
-      mattr_accessor :instance
-      
-      # set a value in the store with the given key. delegates to the returnstore. 
-      def self.set(key, value)
-        self.instance.set(key, value)
-      end
-      
-      # get a value from the store. this should be destructive. delegates to the returnstore. 
-      def self.get(key)
-        self.instance.get(key)
-      end
-      
-      #
-      #  Base Class for Return Stores. Subclasses need to implement set and get. 
-      #
-      class Base
-        
-        # set a value in the store with the given key. 
-        def set(key, value)
-          raise NotImplementedError.new("set(key, value) not implemented in #{ self.class }")
-        end
-      
-        # get a value from the store. this should be destructive.
-        def get(key)
-          raise NotImplementedError.new("get(key) not implemented in #{ self.class }")
-        end
-        
-        def iterator(key)
-          Workling::Return::Store::Iterator.new(key)
-        end
-        
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-#
-#  Iterator class for iterating over return values. 
-#
-module Workling
-  module Return
-    module Store
-      class Iterator
-        
-        include Enumerable
-        
-        def initialize(uid)
-          @uid = uid
-        end
-        
-        def each
-          while item = Workling.return.get(@uid)
-            yield item
-          end
-        end
-        
-      end
-    end
-  end
-end

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

@@ -1,26 +0,0 @@
-require 'workling/return/store/base'
-
-#
-#  Stores directly into memory. This is for tests only - not for production use. aight?
-#
-module Workling
-  module Return
-    module Store
-      class MemoryReturnStore < Base
-        attr_accessor :sky
-        
-        def initialize
-          self.sky = Hash.new([])
-        end
-        
-        def set(key, value)
-          self.sky[key] << value
-        end
-        
-        def get(key)
-          self.sky[key].shift
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-require 'workling/return/store/base'
-require 'workling/rudeq/client'
-
-module Workling
-  module Return
-    module Store
-      class RudeqReturnStore < Base
-        cattr_accessor :client
-        
-        def initialize
-          self.class.client = Workling::Rudeq::Client.new
-        end
-        
-        def set(key, value)
-          self.class.client.set(key, value)
-        end
-        
-        def get(key)
-          self.class.client.get(key)
-        end
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-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

@@ -1,13 +0,0 @@
-#
-#  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

@@ -1,55 +0,0 @@
-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/lib/workling/rudeq.rb

@@ -1,7 +0,0 @@
-module Workling
-  module Rudeq
-    def self.config
-      @@config ||=  {:queue_class => "RudeQueue"}
-    end    
-  end
-end

data/lib/workling/rudeq/client.rb

@@ -1,17 +0,0 @@
-require 'workling/rudeq'
-
-module Workling
-  module Rudeq
-    class Client
-      attr_reader :queue
-      
-      def initialize 
-        @queue = Workling::Rudeq.config[:queue_class].constantize
-      end
-      
-      def method_missing(method, *args)
-        @queue.send(method, *args)
-      end
-    end
-  end
-end

data/lib/workling/rudeq/poller.rb

@@ -1,116 +0,0 @@
-require 'workling/rudeq'
-
-module Workling
-  module Rudeq
-    
-    class Poller
-      
-      cattr_accessor :sleep_time # Seconds to sleep before looping
-      cattr_accessor :reset_time # Seconds to wait while resetting connection
-
-      def initialize(routing)
-        Poller.sleep_time = Workling::Rudeq.config[:sleep_time] || 2
-        Poller.reset_time = Workling::Rudeq.config[:reset_time] || 30
-          
-        @routing = routing
-        @workers = ThreadGroup.new
-      end      
-      
-      def logger
-        Workling::Base.logger
-      end
-    
-      def listen
-                
-        # Allow concurrency for our tasks
-        ActiveRecord::Base.allow_concurrency = true
-
-        # Create a thread for each worker.
-        Workling::Discovery.discovered.each do |clazz|
-          logger.debug("Discovered listener #{clazz}")
-          @workers.add(Thread.new(clazz) { |c| clazz_listen(c) })
-        end
-        
-        # Wait for all workers to complete
-        @workers.list.each { |t| t.join }
-
-        # Clean up all the connections.
-        ActiveRecord::Base.verify_active_connections!
-      end
-      
-      # gracefully stop processing
-      def stop
-        @workers.list.each { |w| w[:shutdown] = true }
-      end
-      
-      ##
-      ## Thread procs
-      ##
-      
-      # Listen for one worker class
-      def clazz_listen(clazz)
-        
-        logger.debug("Listener thread #{clazz.name} started")
-           
-        # Read thread configuration if available
-        if Rudeq.config.has_key?(:listeners)
-          if Rudeq.config[:listeners].has_key?(clazz.to_s)
-            config = Rudeq.config[:listeners][clazz.to_s].symbolize_keys
-            thread_sleep_time = config[:sleep_time] if config.has_key?(:sleep_time)
-          end
-        end
-
-        hread_sleep_time ||= self.class.sleep_time
-        
-        connection = Workling::Rudeq::Client.new
-        puts "** Starting Workling::Rudeq::Client for #{clazz.name} queue"
-        
-        # Start dispatching those messages
-        while (!Thread.current[:shutdown]) do
-          begin
-            
-            # Keep MySQL connection alive
-            unless ActiveRecord::Base.connection.active?
-              unless ActiveRecord::Base.connection.reconnect!
-                logger.fatal("FAILED - Database not available")
-                break
-              end
-            end
-
-            # Dispatch and process the messages
-            n = dispatch!(connection, clazz)
-            logger.debug("Listener thread #{clazz.name} processed #{n.to_s} queue items") if n > 0
-            sleep(self.class.sleep_time) unless n > 0
-          end
-        end
-        
-        logger.debug("Listener thread #{clazz.name} ended")
-      end
-      
-      # Dispatcher for one worker class.
-      # Returns the number of worker methods called
-      def dispatch!(connection, clazz)
-        n = 0
-        for queue in @routing.queue_names_routing_class(clazz)
-          begin
-            result = connection.get(queue)
-            if result
-              n += 1
-              handler = @routing[queue]
-              method_name = @routing.method_name(queue)
-              logger.debug("Calling #{handler.class.to_s}\##{method_name}(#{result.inspect})")
-              handler.send(method_name, result)
-            end
-          rescue
-            logger.error("FAILED to connect with queue #{ queue }: #{ e } }")
-            raise e
-          rescue Object => e
-            logger.error("FAILED to process queue #{ queue }. #{ @routing[queue] } could not handle invocation of #{ @routing.method_name(queue) } with #{ result.inspect }: #{ e }.\n#{ e.backtrace.join("\n") }")
-          end
-        end
-        
-        return n
-      end
-    end
-  end
-end

data/test/class_and_method_routing_test.rb

@@ -1,18 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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