derfred-workling 0.4.9.1 → 0.4.9.2

data/lib/workling/remote/invokers/threaded_poller.rb

@@ -0,0 +1,153 @@
+require 'workling/remote/invokers/base'
+
+#
+#  A threaded polling Invoker. 
+# 
+#  TODO: refactor this to make use of the base class. 
+# 
+module Workling
+  module Remote
+    module Invokers
+      class ThreadedPoller < Workling::Remote::Invokers::Base
+        
+        cattr_accessor :sleep_time, :reset_time
+      
+        def initialize(routing, client_class)
+          super
+          
+          ThreadedPoller.sleep_time = Workling.config[:sleep_time] || 2
+          ThreadedPoller.reset_time = Workling.config[:reset_time] || 30
+          
+          @workers = ThreadGroup.new
+          @mutex = Mutex.new
+        end      
+          
+        def listen
+          # 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 }
+
+          logger.debug("Reaped listener threads. ")
+        
+          # Clean up all the connections.
+          if defined?(ActiveRecord::Base)
+            ActiveRecord::Base.verify_active_connections!
+          end
+
+          logger.debug("Cleaned up connection: out!")
+        end
+      
+        # Check if all Worker threads have been started. 
+        def started?
+          logger.debug("checking if started... list size is #{ worker_threads }")
+          Workling::Discovery.discovered.size == worker_threads
+        end
+        
+        # number of worker threads running
+        def worker_threads
+          @workers.list.size
+        end
+      
+        # Gracefully stop processing
+        def stop
+          logger.info("stopping threaded poller...")
+          sleep 1 until started? # give it a chance to start up before shutting down. 
+          logger.info("Giving Listener Threads a chance to shut down. This may take a while... ")
+          @workers.list.each { |w| w[:shutdown] = true }
+          logger.info("Listener threads were shut down.  ")
+        end
+
+        # Listen for one worker class
+        def clazz_listen(clazz)
+          logger.debug("Listener thread #{clazz.name} started")
+           
+          # Read thread configuration if available
+          if Workling.config.has_key?(:listeners)
+            if Workling.config[:listeners].has_key?(clazz.to_s)
+              config = Workling.config[:listeners][clazz.to_s].symbolize_keys
+              thread_sleep_time = config[:sleep_time] if config.has_key?(:sleep_time)
+              Thread.current.priority = config[:priority] if config.has_key?(:priority)
+            end
+          end
+
+          thread_sleep_time ||= self.class.sleep_time
+                
+          # Setup connection to client (one per thread)
+          connection = @client_class.new
+          connection.connect
+          logger.info("** Starting client #{ connection.class } for #{clazz.name} queue")
+     
+          # Start dispatching those messages
+          while (!Thread.current[:shutdown]) do
+            begin
+            
+              # Thanks for this Brent! 
+              #
+              #     ...Just a heads up, due to how rails’ MySQL adapter handles this  
+              #     call ‘ActiveRecord::Base.connection.active?’, you’ll need 
+              #     to wrap the code that checks for a connection in in a mutex.
+              #
+              #     ....I noticed this while working with a multi-core machine that 
+              #     was spawning multiple workling threads. Some of my workling 
+              #     threads would hit serious issues at this block of code without 
+              #     the mutex.            
+              #
+              if defined?(ActiveRecord::Base)
+                @mutex.synchronize do 
+                  unless ActiveRecord::Base.connection.active?  # Keep MySQL connection alive
+                    unless ActiveRecord::Base.connection.reconnect!
+                      logger.fatal("Failed - Database not available!")
+                      break
+                    end
+                  end
+                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(thread_sleep_time) unless n > 0
+            
+            # If there is a memcache error, hang for a bit to give it a chance to fire up again
+            # and reset the connection.
+            rescue Workling::WorklingConnectionError
+              logger.warn("Listener thread #{clazz.name} failed to connect. Resetting connection.")
+              sleep(self.class.reset_time)
+              connection.reset
+            end
+          end
+        
+          logger.debug("Listener thread #{clazz.name} ended")
+        end
+      
+        # Dispatcher for one worker class. Will throw MemCacheError if unable to connect.
+        # 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.retrieve(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.dispatch_to_worker_method(method_name, result)
+              end
+            rescue Workling::WorklingError => e
+              logger.error("FAILED to connect with queue #{ queue }: #{ e } }")
+              raise e
+            end
+          end
+        
+          return n
+        end
+      end
+    end
+  end
+end

data/lib/workling/remote/runners/amqp_exchange_runner.rb

@@ -0,0 +1,45 @@
+require 'workling/remote/runners/base'
+
+#
+#  Runs Jobs over a Client. The client should be a subclass of Workling::Client::Base. 
+#  Set the client like this: 
+#
+#      Workling::Remote::Runners::ClientRunner.client = Workling::Clients::AmqpClient.new
+#
+#  Jobs are dispatched by requesting them on the Client. The Runner takes care of mapping of queue names to worker code. 
+#  this is done with Workling::ClassAndMethodRouting, but you can use your own by sublassing Workling::Routing. 
+#  Don’t worry about any of this if you’re not dealing directly with the queues.
+#
+#  There’s a workling-client daemon that uses the configured invoker to retrieve work and dispatching these to the 
+#  responsible workers. If you intend to run this on a remote machine, then just check out your rails project 
+#  there and start up the workling client like this: ruby script/workling_client run.
+#
+module Workling
+  module Remote
+    module Runners
+      class AmqpExchangeRunner < Workling::Remote::Runners::Base
+        
+        # Routing class. Workling::Routing::ClassAndMethodRouting.new by default. 
+        cattr_accessor :routing
+        @@routing ||= Workling::Routing::ClassAndMethodRouting.new
+        
+        # The workling Client class. Workling::Clients::MemcacheQueueClient.new by default. 
+        cattr_accessor :client
+        @@client ||= Workling::Clients::AmqpExchangeClient.new
+        
+        # enqueues the job onto the client
+        def run(clazz, method, options = {})
+          
+          # neet to connect in here as opposed to the constructor, since the EM loop is
+          # not available there. 
+          @connected ||= self.class.client.connect
+
+          # NOTE - currently hardcoded to use the default exchange
+          self.class.client.request("amq.topic", options)    
+          
+          return nil
+        end
+      end
+    end
+  end
+end

data/lib/workling/remote/runners/backgroundjob_runner.rb

@@ -0,0 +1,35 @@
+require 'workling/remote/runners/base'
+
+#
+#  Use Ara Howards BackgroundJob to run the work. BackgroundJob loads Rails once per requested Job. 
+#  It persists over the database, and there is no requirement for separate processes to be started. 
+#  Since rails has to load before each request, it takes a moment for the job to run. 
+#
+module Workling
+  module Remote
+    module Runners
+      class BackgroundjobRunner < Workling::Remote::Runners::Base
+        cattr_accessor :routing
+        
+        def initialize
+          BackgroundjobRunner.routing = 
+            Workling::Routing::ClassAndMethodRouting.new
+        end
+        
+        #  passes the job to bj by serializing the options to xml and passing them to
+        #  ./script/bj_invoker.rb, which in turn routes the deserialized args to the
+        #  appropriate worker. 
+        def run(clazz, method, options = {})
+          stdin = @@routing.queue_for(clazz, method) + 
+                  " " + 
+                  options.to_xml(:indent => 0, :skip_instruct => true)
+                  
+          Bj.submit "./script/runner ./script/bj_invoker.rb", 
+            :stdin => stdin
+          
+          return nil # that means nothing!
+        end
+      end
+    end
+  end
+end

data/lib/workling/remote/runners/base.rb

@@ -0,0 +1,42 @@
+#
+#  Base class for Workling Runners.
+#
+#  Runners must subclass this and implement the method 
+#
+#     Workling::Remote::Runners::Base#run(clazz, method, options = {})
+#
+#  which is responsible for pushing the requested job into the background. Depending
+#  on the Runner, this may require other code to dequeue the job. The actual
+#  invocation of the runner should be done like this: 
+#
+#      Workling.find(clazz, method).dispatch_to_worker_method(method, options)
+#
+#  This ensures for consistent logging and handling of propagated exceptions. You can
+#  also call the convenience method 
+#       
+#      Workling::Remote::Runners::Base#dispatch!(clazz, method, options)
+#
+#  which invokes this for you. 
+#
+module Workling
+  module Remote
+    module Runners
+      class Base
+        
+        # runner uses this to connect to a job broker
+        cattr_accessor :client
+        
+        # default logger defined in Workling::Base.logger
+        def logger
+          Workling::Base.logger
+        end
+
+        # find the worker instance and invoke it. Invoking the worker method like this ensures for 
+        # consistent logging and handling of propagated exceptions. 
+        def dispatch!(clazz, method, options)
+          Workling.find(clazz, method).dispatch_to_worker_method(method, options)
+        end
+      end
+    end
+  end
+end

data/lib/workling/remote/runners/client_runner.rb

@@ -0,0 +1,46 @@
+require 'workling/remote/runners/base'
+require 'workling/routing/class_and_method_routing'
+require 'workling/clients/memcache_queue_client'
+
+#
+#  Runs Jobs over a Client. The client should be a subclass of Workling::Client::Base. 
+#  Set the client like this: 
+#
+#      Workling::Remote::Runners::ClientRunner.client = Workling::Clients::AmqpClient.new
+#
+#  Jobs are dispatched by requesting them on the Client. The Runner takes care of mapping of queue names to worker code. 
+#  this is done with Workling::ClassAndMethodRouting, but you can use your own by sublassing Workling::Routing. 
+#  Don’t worry about any of this if you’re not dealing directly with the queues.
+#
+#  There’s a workling-client daemon that uses the configured invoker to retrieve work and dispatching these to the 
+#  responsible workers. If you intend to run this on a remote machine, then just check out your rails project 
+#  there and start up the workling client like this: ruby script/workling_client run.
+#
+module Workling
+  module Remote
+    module Runners
+      class ClientRunner < Workling::Remote::Runners::Base
+        
+        # Routing class. Workling::Routing::ClassAndMethodRouting.new by default. 
+        cattr_accessor :routing
+        @@routing ||= Workling::Routing::ClassAndMethodRouting.new
+        
+        # The workling Client class. Workling::Clients::MemcacheQueueClient.new by default. 
+        cattr_accessor :client
+        @@client ||= Workling::Clients::MemcacheQueueClient.new
+        
+        # enqueues the job onto the client
+        def run(clazz, method, options = {})
+          
+          # neet to connect in here as opposed to the constructor, since the EM loop is
+          # not available there. 
+          @connected ||= self.class.client.connect
+          
+          self.class.client.request(@@routing.queue_for(clazz, method), options)    
+          
+          return nil
+        end
+      end
+    end
+  end
+end

data/lib/workling/remote/runners/not_remote_runner.rb

@@ -0,0 +1,23 @@
+require 'workling/remote/runners/base'
+
+#
+# directly dispatches to the worker method, in-process. options are first marshalled then dumped
+# in order to simulate the sideeffects of a remote call.
+#
+module Workling
+  module Remote
+    module Runners
+      class NotRemoteRunner < Workling::Remote::Runners::Base
+        
+        # directly dispatches to the worker method, in-process. options are first marshalled then dumped
+        # in order to simulate the sideeffects of a remote call. 
+        def run(clazz, method, options = {})
+          options = Marshal.load(Marshal.dump(options)) # get this to behave more like the remote runners
+          dispatch!(clazz, method, options) 
+          
+          return nil # nada. niente.
+        end
+      end
+    end
+  end
+end

data/lib/workling/remote/runners/not_runner.rb

@@ -0,0 +1,17 @@
+require 'workling/remote/runners/base'
+
+#
+# this does absolutely nothing, mainly for testing
+#
+
+module Workling
+  module Remote
+    module Runners
+      class NotRunner < Workling::Remote::Runners::Base
+        def run(clazz, method, options = {})
+          return nil # nada. niente.
+        end
+      end
+    end
+  end
+end

data/lib/workling/remote/runners/rudeq_runner.rb

@@ -0,0 +1,23 @@
+require 'workling/remote/runners/base'
+
+module Workling
+  module Remote
+    module Runners
+      class RudeqRunner < Workling::Remote::Runners::Base
+        cattr_accessor :routing
+        cattr_accessor :client
+        
+        def initialize
+          RudeqRunner.client = Workling::Rudeq::Client.new
+          RudeqRunner.routing = Workling::Routing::ClassAndMethodRouting.new
+        end
+        
+        def run(clazz, method, options = {})
+          RudeqRunner.client.set(@@routing.queue_for(clazz, method), options)
+          
+          return nil # empty.
+        end
+      end
+    end
+  end
+end

data/lib/workling/remote/runners/spawn_runner.rb

@@ -0,0 +1,38 @@
+require 'workling/remote/runners/base'
+
+#
+#  Run the job over the spawn plugin. Refer to the README for instructions on 
+#  installing Spawn. 
+#
+#  Spawn forks the entire process once for each job. This means that the job starts 
+#  with a very low latency, but takes up more memory for each job. 
+# 
+#  It's also possible to configure Spawn to start a Thread for each job. Do this
+#  by setting
+#
+#      Workling::Remote::Runners::SpawnRunner.options = { :method => :thread }
+#
+#  Have a look at the Spawn README to find out more about the characteristics of this. 
+#
+module Workling
+  module Remote
+    module Runners
+      class SpawnRunner < Workling::Remote::Runners::Base
+        cattr_accessor :options
+        
+        # use thread for development and test modes. easier to hunt down exceptions that way. 
+        @@options = { :method => (RAILS_ENV == "test" || RAILS_ENV == "development" ? :fork : :thread) }
+        include Spawn if Workling.spawn_installed?
+        
+        # dispatches to Spawn, using the :fork option. 
+        def run(clazz, method, options = {})
+          spawn(SpawnRunner.options) do # exceptions are trapped in here. 
+            dispatch!(clazz, method, options)
+          end
+          
+          return nil # that means nothing!
+        end
+      end
+    end
+  end
+end

data/lib/workling/remote/runners/starling_runner.rb

@@ -0,0 +1,13 @@
+require 'workling/remote/runners/client_runner'
+
+#
+#  DEPRECATED. Should use ClientRunner instead. 
+#
+module Workling
+  module Remote
+    module Runners
+      class StarlingRunner < Workling::Remote::Runners::ClientRunner
+      end
+    end
+  end
+end

data/lib/workling/remote.rb

@@ -0,0 +1,69 @@
+require "workling/remote/runners/not_remote_runner"
+require "workling/remote/runners/spawn_runner"
+require "workling/remote/runners/starling_runner"
+require "workling/remote/runners/backgroundjob_runner"
+require "workling/remote/invokers/threaded_poller"
+
+require 'digest/md5'
+
+#
+#  Scoping Module for Runners. 
+#
+module Workling
+  module Remote
+
+    # Select which invoke to load based on what is defined in workling.yml. Defaults to thread_poller
+    # if none are specified.
+    def self.select_invoker
+      case(Workling.config[:invoker])
+      when 'basic_poller'
+        Workling::Remote::Invokers::BasicPoller
+
+      when 'thread_pool_poller'
+        Workling::Remote::Invokers::ThreadPoolPoller
+
+      when 'eventmachine_subscriber'
+        Workling::Remote::Invokers::EventmachineSubscriber
+
+      when 'threaded_poller', nil
+        Workling::Remote::Invokers::ThreadedPoller
+
+      else
+        Workling.logger.error("Nothing is known about #{Workling.config[:invoker]} defaulting to thread_poller")
+        Workling::Remote::Invokers::ThreadedPoller
+      end
+    end
+
+    # set the desired runner here. this is initialized with Workling.default_runner. 
+    mattr_accessor :dispatcher
+
+    # set the desired invoker. this class grabs work from the job broker and executes it.
+    mattr_accessor :invoker
+    @@invoker ||= self.select_invoker
+
+    mattr_accessor :routing
+    @@routing ||= Workling::Routing::ClassAndMethodRouting
+
+    # retrieve the dispatcher or instantiate it using the defaults
+    def self.dispatcher
+      @@dispatcher ||= Workling.default_runner
+    end
+    
+    # generates a unique identifier for this particular job. 
+    def self.generate_uid(clazz, method)
+      uid = ::Digest::MD5.hexdigest("#{ clazz }:#{ method }:#{ rand(1 << 64) }:#{ Time.now }")
+      "#{ clazz.to_s.tableize }/#{ method }/#{ uid }".split("/").join(":")
+    end
+    
+    # dispatches to a workling. writes the :uid for this work into the options hash, so make 
+    # sure you pass in a hash if you want write to a return store in your workling.
+    def self.run(clazz, method, options = {})
+      uid = Workling::Remote.generate_uid(clazz, method)
+      options[:uid] = uid if options.kind_of?(Hash) && !options[:uid]
+      Workling.find(clazz, method) # this line raises a WorklingError if the method does not exist. 
+      dispatcher.run(clazz, method, options)
+      uid
+    end
+
+  end
+end

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

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

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

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

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

@@ -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,16 @@
+#
+#  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
+#      @@logger ||= ::RAILS_DEFAULT_LOGGER   
+#      cattr_accessor :logger
+      
+      def method_name
+        raise Exception.new("method_name not implemented.")
+      end
+    end
+  end
+end