workling 0.4.9.7

data/lib/workling/remote.rb

@@ -0,0 +1,38 @@
+require 'digest/md5'
+
+#
+#  Scoping Module for Runners. 
+#
+module Workling
+  module Remote
+
+    # which object to use for routing
+    mattr_writer :routing
+    def self.routing
+      @@routing ||= Workling::Routing::ClassAndMethodRouting.new
+    end
+
+    # which client to use for dispatching
+    mattr_accessor :client
+    def self.client
+      @@client ||= Workling.select_and_build_client
+    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.
+      client.dispatch(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,24 @@
+#
+#  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/starling_return_store.rb

@@ -0,0 +1,30 @@
+#
+#  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.client.set(key, value)
+        end
+
+        # get a value from starling queue 'key'.
+        def get(key)
+          self.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 @@
+#
+#  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(*args)
+        super
+
+        build
+      end
+      
+      # returns the worker method name, given the routing string. 
+      def method_name(queue)
+        self[queue].method_for(queue)
+      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)
+        # this is lifted from the Rails constantize method
+        clazz = Object.module_eval("::#{clazz}") unless clazz.is_a?(Class)
+        clazz.queue_for method
+      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.public_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/routing/static_routing.rb

@@ -0,0 +1,43 @@
+#
+#  Holds a single route for a dedicated worker (if you want more worker processes, run more workers)
+#
+module Workling
+  module Routing
+    class StaticRouting < Base
+
+      #
+      # ./script/workling_client run -- <worker_class> <worker_method> <routing_key>      
+      # ./script/workling_client run -- <worker_class> <worker_method> <routing_key> <queue_name>
+      #
+      def initialize(*args)
+        @worker = args[0].constantize.new
+        @method_name = args[1]
+        @routing_key = args[2]
+
+        if(args.size==4)
+          @queue_name = args[3]
+        else
+          @queue_name = [@worker.class.to_s.tableize, @method_name, @routing_key].join("__")
+        end
+
+        # so routing[x] hash access works as expected
+        self.default = @worker
+      end
+
+      # returns the worker method name, given the routing string. 
+      def method_name(queue=nil); @method_name; end
+
+      def routing_key_for; @routing_key; end
+
+      # returns the routing string, given a class and method. delegating.
+      # TODO - we can check for consistency here with clazz and methods vs. current configuration of this single route
+      def queue_for(clazz=nil, method=nil); @queue_name; end
+   
+      # returns array containing the single configured route
+      def queue_names; [@queue_name]; end
+      
+      # TODO - not sure what this is...
+      def queue_names_routing_class(clazz); @worker.class; end         
+    end
+  end
+end

data/lib/workling_daemon.rb

@@ -0,0 +1,111 @@
+require 'optparse'
+
+class WorklingDaemon
+
+  def self.partition_options(args)
+    daemon = []
+    workling = []
+    split_point = args.index("--") || args.size
+    daemon = args[0...split_point] if split_point > 0
+    workling = args[(split_point+1)..-1] if split_point and split_point < args.size
+    [daemon, workling]
+  end
+
+  def self.partition_daemons_options(args)
+    standard_options = %W{start stop restart run zap -t --ontop -f --force -h --help --version}
+    pass_through = args.select { |a| standard_options.include? a }
+    custom_options = args.reject { |a| standard_options.include? a }
+
+    [pass_through, custom_options]
+  end
+
+  def self.parse_daemon_options(argv)
+    options = {}
+    pass_through, args = partition_daemons_options argv
+    opts = OptionParser.new do |opts|
+      opts.banner = 'Usage: myapp [options]'
+      opts.separator ''
+      opts.on('-a', '--app-name APP_NAME', String,"specify the process name") { |v| options[:app_name] = v }
+      opts.on('-d', '--dir DIR', String, "the directory to run in") { |v| options[:dir] = v }
+      opts.on('-m', '--monitor',"specify the process name") { |v| options[:monitor] = true }
+      opts.on('-t', '--ontop') { |k, v| pass_through << v  }
+    end
+    opts.parse!(partition_options(args).first)
+    options.merge(:ARGV => pass_through)
+  end
+
+  def self.parse_workling_options(args)
+    options = {}
+    opts = OptionParser.new do |opts|
+      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] = 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.initialize_workling(options)
+    Workling.load_path = options[:load_path] if options[:load_path]
+    Workling::Discovery.discover!
+
+    if options[:config_path]
+      Workling.config_path = options[:config_path]
+      Workling.config
+    else
+      Workling.config = extract_options options
+    end
+
+    Workling.select_and_build_invoker
+  end
+
+  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")
+    else
+      ENV["RAILS_ENV"] = options[:rails_env]
+      puts "=> Loading Rails with #{ENV["RAILS_ENV"]} environment..."
+      require options[:rails_root] + '/config/environment'
+
+      ActiveRecord::Base.logger = Workling::Base.logger
+      ActionController::Base.logger = Workling::Base.logger
+
+      puts '** Rails loaded.'
+    end
+  end
+
+
+  def self.run(options)
+    boot_with options
+    poller = initialize_workling(options)
+
+    puts "** Starting #{ poller.class }..."
+    puts '** Use CTRL-C to stop.'
+
+    trap(:INT) { poller.stop; exit }
+
+    begin
+      poller.listen
+    ensure
+      puts '** No Worklings found.' if Workling::Discovery.discovered.empty?
+      puts '** Exiting'
+    end
+  end
+
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification 
+name: workling
+version: !ruby/object:Gem::Version 
+  version: 0.4.9.7
+platform: ruby
+authors: 
+- Rany Keddo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-25 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: easily do background work in rails, without commiting to a particular runner. comes with starling, bj and spawn runners.
+email: nicolas@marchildon.net
+executables: 
+- workling_client
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- CHANGES.markdown
+- VERSION.yml
+- README.markdown
+- TODO.markdown
+- lib/extensions/cattr_accessor.rb
+- lib/extensions/mattr_accessor.rb
+- lib/workling/base.rb
+- lib/workling/clients/amqp_client.rb
+- lib/workling/clients/amqp_exchange_client.rb
+- lib/workling/clients/backgroundjob_client.rb
+- lib/workling/clients/base.rb
+- lib/workling/clients/broker_base.rb
+- lib/workling/clients/memcache_queue_client.rb
+- lib/workling/clients/memory_queue_client.rb
+- lib/workling/clients/not_client.rb
+- lib/workling/clients/not_remote_client.rb
+- lib/workling/clients/rude_q_client.rb
+- lib/workling/clients/spawn_client.rb
+- lib/workling/clients/sqs_client.rb
+- lib/workling/clients/thread_client.rb
+- lib/workling/clients/xmpp_client.rb
+- lib/workling/discovery.rb
+- lib/workling/invokers/amqp_single_subscriber.rb
+- lib/workling/invokers/base.rb
+- lib/workling/invokers/basic_poller.rb
+- lib/workling/invokers/eventmachine_subscriber.rb
+- lib/workling/invokers/looped_subscriber.rb
+- lib/workling/invokers/thread_pool_poller.rb
+- lib/workling/invokers/threaded_poller.rb
+- lib/workling/remote.rb
+- lib/workling/return/store/base.rb
+- lib/workling/return/store/iterator.rb
+- lib/workling/return/store/memory_return_store.rb
+- lib/workling/return/store/starling_return_store.rb
+- lib/workling/routing/base.rb
+- lib/workling/routing/class_and_method_routing.rb
+- lib/workling/routing/static_routing.rb
+- lib/workling.rb
+- lib/workling_daemon.rb
+- contrib/bj_invoker.rb
+- contrib/starling_status.rb
+has_rdoc: true
+homepage: http://github.com/derfred/workling
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 2
+summary: easily do background work in rails, without commiting to a particular runner. comes with starling, bj and spawn runners.
+test_files: []
+