derfred-workling 0.4.9.5 → 0.4.9.6

data/bin/workling_client

@@ -14,12 +14,11 @@ daemon_options = {
 }.merge(WorklingDaemon.parse_daemon_options(ARGV))
 
 workling_options = {
-  :client_class => "Workling::Clients::MemcacheQueueClient",
-  :invoker_class => "Workling::Remote::Invokers::ThreadedPoller",
-  :routing_class => "Workling::Routing::ClassAndMethodRouting",
+  :client_class => "memcache_queue",
+  :invoker_class => "threaded_poller",
+  :routing_class => "class_and_method",
   :rails_root => Dir.pwd,
   :load_path => ['app/workers/**/*.rb'],
-  :config_path => "config/workling.yml",
   :rails_env => (ENV['RAILS_ENV'] || "development").dup,
   :no_rails => false
 }.merge(WorklingDaemon.parse_workling_options(ARGV))

data/lib/workling.rb

@@ -27,7 +27,6 @@ module Workling
       super "config/workling.yml configured to connect to queue server on #{ Workling.config[:listens_on] } for this environment. could not connect to queue server on this host:port. for starling users: pass starling the port with -p flag when starting it. If you don't want to use Starling, then explicitly set Workling::Remote.dispatcher (see README for an example)"
     end
   end
-
   class ConfigurationError < WorklingError
     def initialize
       super File.exist?(Workling.path('config', 'starling.yml')) ? 
@@ -35,7 +34,7 @@ module Workling
         "config/workling.yml could not be loaded. check out README.markdown to see what this file should contain. "
     end
   end
-  
+
   def self.path(*args)
     if defined?(RAILS_ROOT)
       File.join(RAILS_ROOT, *args)
@@ -62,18 +61,42 @@ module Workling
   # starling, spawn, or bj, in that order. if none of these are found, notremoterunner will
   # be used. 
   #
-  def self.select_and_build_default_client
+  def self.select_default_client
     if env == "test"
-      Workling::Clients::NotRemoteClient.new
+      Workling::Clients::NotRemoteClient
     elsif Workling::Clients::SpawnClient.installed?
-      Workling::Clients::SpawnClient.new
+      Workling::Clients::SpawnClient
     elsif Workling::Clients::BackgroundjobClient.installed?
-      Workling::Clients::BackgroundjobClient.new
+      Workling::Clients::BackgroundjobClient
     else
-      Workling::Clients::NotRemoteClient.new
+      Workling::Clients::NotRemoteClient
     end
   end
 
+  def self.clients
+    {
+      'amqp' => Workling::Clients::AmqpClient,
+      'amqp_exchange' => Workling::Clients::AmqpExchangeClient,
+      'memcache' => Workling::Clients::MemcacheQueueClient,
+      'starling' => Workling::Clients::MemcacheQueueClient,
+      'memory_queue' => Workling::Clients::MemoryQueueClient,
+      'sqs' => Workling::Clients::SqsClient,
+      'xmpp' => Workling::Clients::XmppClient,
+      'backgroundjob' => Workling::Clients::BackgroundjobClient,
+      'not_remote' => Workling::Clients::NotRemoteClient,
+      'not' => Workling::Clients::NotClient,
+      'spawn' => Workling::Clients::SpawnClient,
+      'thread' => Workling::Clients::ThreadClient,
+      'rudeq' => Workling::Clients::RudeQClient
+    }
+  end
+
+  def self.select_client
+    client_class = clients[Workling.config[:client]] || select_default_client
+    client_class.load
+    client_class
+  end
+
   #
   # this will build the client to use for job dispatching and retrieval
   # The look up does the following:
@@ -82,46 +105,34 @@ module Workling
   #    3. otherwise the default client is built using the Workling.select_and_build_default_client method
   #
   def self.select_and_build_client
-    case(Workling.config[:client])
-    when 'amqp'
-      Workling::Clients::AmqpClient.new
-
-    when 'amqp_exchange'
-      Workling::Clients::AmqpExchangeClient.new
-
-    when 'memcache', 'starling'
-      Workling::Clients::MemcacheQueueClient.new
-
-    when 'memory_queue'   # this one is pretty useles...
-      Workling::Clients::MemoryQueueClient.new
-
-    when 'sqs'
-      Workling::Clients::SqsClient.new
-
-    when 'xmpp'
-      Workling::Clients::XmppClient.new
-
-    when 'backgroundjob'
-      Workling::Clients::BackgroundjobClient.new
-
-    when 'not_remote'
-      Workling::Clients::NotRemoteClient.new
-
-    when 'not'
-      Workling::Clients::NotClient.new
-
-    when 'spawn'
-      Workling::Clients::SpawnClient.new
-
-    when 'thread'
-      Workling::Clients::ThreadClient.new
+    select_client.new
+  end
 
-    when 'rudeq'
-      Workling::Clients::RudeQClient.new
+  #
+  # this will select the routing class
+  #
+  def self.select_and_build_routing
+    routing_class = {
+      'class_and_method' => Workling::Routing::ClassAndMethodRouting,
+      'static' => Workling::Routing::StaticRouting
+    }[Workling.config[:routing]] || Workling::Routing::ClassAndMethodRouting
+    routing_class.new
+  end
 
-    else
-      select_and_build_default_client
-    end
+  #
+  # this will build the invoker which will run the daemon
+  #
+  def self.select_and_build_invoker
+    invoker_class = {
+      'basic_poller' => Workling::Invokers::BasicPoller,
+      'thread_pool_poller' => Workling::Invokers::ThreadPoolPoller,
+      'threaded_poller' => Workling::Invokers::ThreadedPoller,
+
+      'eventmachine_subscriber' => Workling::Invokers::EventmachineSubscriber,
+      'looped_subscriber' => Workling::Invokers::LoopedSubscriber,
+      'amqp_single_subscriber' => Workling::Invokers::AmqpSingleSubscriber,
+    }[Workling.config[:invoker]] || Workling::Invokers::BasicPoller
+    invoker_class.new(select_and_build_routing, select_client)
   end
 
   #

data/lib/workling/clients/amqp_client.rb

@@ -25,22 +25,27 @@ module Workling
           raise WorklingError.new("couldn't start amq client. if you're running this in a server environment, then make sure the server is evented (ie use thin or evented mongrel, not normal mongrel.)")
         end
       end
-      
+
       # no need for explicit closing. when the event loop
       # terminates, the connection is closed anyway. 
       def close; true; end
-      
+
       # subscribe to a queue
       def subscribe(key)
-        @amq.queue(key).subscribe do |value|
+        @amq.queue(queue_for(key)).subscribe do |value|
           data = Marshal.load(value) rescue value
           yield data
         end
       end
-      
+
       # request and retrieve work
-      def retrieve(key); @amq.queue(key); end
-      def request(key, value); @amq.queue(key).publish(Marshal.dump(value)); end
+      def retrieve(key); @amq.queue(queue_for(key)); end
+      def request(key, value); @amq.queue(queue_for(key)).publish(Marshal.dump(value)); end
+
+      private
+        def queue_for(key)
+          "#{Workling.config[:prefix]}#{key}"
+        end
     end
   end
 end

data/lib/workling/clients/memcache_queue_client.rb

@@ -44,7 +44,8 @@ module Workling
       #  to queueserver.
       #
       def connect
-        @queueserver_urls = Workling.config[:listens_on].split(',').map { |url| url ? url.strip : url }
+        listens_on = Workling.config[:listens_on] || "localhost:22122"
+        @queueserver_urls = listens_on.split(',').map { |url| url ? url.strip : url }
         options = [@queueserver_urls, Workling.config[:memcache_options]].compact
         self.connection = ::MemCache.new(*options)
 

data/lib/workling/remote.rb

@@ -23,13 +23,13 @@ module Workling
       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. 
+      Workling.find(clazz, method) # this line raises a WorklingError if the method does not exist.
       client.dispatch(clazz, method, options)
       uid
     end

data/lib/workling_daemon.rb

@@ -40,37 +40,41 @@ class WorklingDaemon
       opts.banner = 'Usage: myapp [options]'
       opts.separator ''
       opts.on('-n', '--no_rails', "do not load Rails") { |v| options[:no_rails] = true }
-      opts.on('-c', '--client CLIENT', String, "specify the client class") { |v| options[:client_class] = v }
-      opts.on('-i', '--invoker INVOKER', String, "specify the invoker class") { |v| options[:invoker_class] = v }
-      opts.on('-r', '--routing ROUTING', String, "specify the routing class") { |v| options[:routing_class] = v }
+      opts.on('-c', '--client CLIENT', String, "specify the client class") { |v| options[:client] = v }
+      opts.on('-i', '--invoker INVOKER', String, "specify the invoker class") { |v| options[:invoker] = v }
+      opts.on('-r', '--routing ROUTING', String, "specify the routing class") { |v| options[:routing] = v }
       opts.on('-l', '--load-path LOADPATH', String, "specify the load_path for the workers") { |v| options[:load_path] = v }
       opts.on('-f', '--config-path CONFIGPATH', String, "specify the path to the workling.yml file") { |v| options[:config_path] = v }
       opts.on('-e', '--environment ENVIRONMENT', String, "specify the environment") { |v| options[:rails_env] = v }
+      opts.on('-p', '--prefix PREFIX', String, "specify the prefix for queues") { |v| options[:prefix] = v }
     end
     opts.parse!(partition_options(args).last)
     options
   end
 
+  def self.extract_options(options)
+    result = {}
+    result[:client] = options[:client] if options[:client]
+    result[:routing] = options[:routing] if options[:routing]
+    result[:invoker] = options[:invoker] if options[:invoker]
+    result
+  end
 
-  def self.build_poller(options)
-    require File.join(File.dirname(__FILE__), 'workling/remote')
-    ["remote/invokers/*.rb", "routing/*.rb"].each do |pattern|
-      Dir.glob(pattern).each do |f|
-        require File.join(File.dirname(f), File.basename(f, ".rb"))
-      end
-    end
-
-    routing_class = Object.module_eval("::#{options[:routing_class]}")
-    client_class = Object.module_eval("::#{options[:client_class]}")
-    invoker_class = Object.module_eval("::#{options[:invoker_class]}")
+  def self.initialize_workling(options)
+    Workling.load_path = options[:load_path] if options[:load_path]
+    Workling::Discovery.discover!
 
-    client_class.load
+    if options[:config_path]
+      Workling.config_path = options[:config_path]
+      Workling.config
+    else
+      Workling.config = extract_options options
+    end
 
-    invoker_class.new(routing_class.new, client_class)
+    Workling.select_and_build_invoker
   end
 
-
-  def self.run(options)
+  def self.boot_with(options)
     if options[:no_rails]
       # if rails is not booted we need to pull in the workling requires manually
       require File.join(File.dirname(__FILE__), "workling")
@@ -78,25 +82,22 @@ class WorklingDaemon
       ENV["RAILS_ENV"] = options[:rails_env]
       puts "=> Loading Rails with #{ENV["RAILS_ENV"]} environment..."
       require options[:rails_root] + '/config/environment'
-    end
 
-    Workling.load_path = options[:load_path]
-    Workling.config_path = options[:config_path]
+      ActiveRecord::Base.logger = Workling::Base.logger
+      ActionController::Base.logger = Workling::Base.logger
+
+      puts '** Rails loaded.'
+    end
+  end
 
-    Workling::Discovery.discover!
-    Workling.config
 
-    poller = build_poller options
+  def self.run(options)
+    boot_with options
+    poller = initialize_workling(options)
 
-    puts '** Rails loaded.'
     puts "** Starting #{ poller.class }..."
     puts '** Use CTRL-C to stop.'
 
-    unless options[:no_rails]
-      ActiveRecord::Base.logger = Workling::Base.logger
-      ActionController::Base.logger = Workling::Base.logger
-    end
-
     trap(:INT) { poller.stop; exit }
 
     begin

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: derfred-workling
 version: !ruby/object:Gem::Version 
-  version: 0.4.9.5
+  version: 0.4.9.6
 platform: ruby
 authors: 
 - Rany Keddo