cloudist 0.2.1 → 0.4.1

data/lib/cloudist/application.rb

@@ -0,0 +1,60 @@
+require "singleton"
+
+module Cloudist
+  class Application
+    include Singleton
+    
+    class << self
+      def start(options = {}, &block)
+        options = instance.settings.update(options)
+        AMQP.start(options) do
+          instance.setup_reconnect_hook!
+
+          instance.instance_eval(&block) if block_given?
+        end
+      end
+      
+      def signal_trap!
+        ::Signal.trap('INT') { Cloudist.stop }
+        ::Signal.trap('TERM'){ Cloudist.stop }
+      end
+    end
+    
+    def settings
+      @@settings ||= default_settings
+    end
+    
+    def settings=(settings_hash)
+      @@settings = default_settings.update(settings_hash)
+    end
+    
+    def default_settings
+      uri = URI.parse(ENV["AMQP_URL"] || 'amqp://guest:guest@localhost:5672/')
+      {
+        :vhost => uri.path,
+        :host => uri.host,
+        :user => uri.user,
+        :port => uri.port || 5672,
+        :pass => uri.password,
+        :heartbeat => 5,
+        :logging => false
+      }
+    rescue Object => e
+      raise "invalid AMQP_URL: (#{uri.inspect}) #{e.class} -> #{e.message}"
+    end
+    
+    private
+    
+    def setup_reconnect_hook!
+      AMQP.conn.connection_status do |status|
+        
+        log.debug("AMQP connection status changed: #{status}")
+        
+        if status == :disconnected
+          AMQP.conn.reconnect(true)
+        end
+      end
+    end
+    
+  end
+end

data/lib/cloudist/core_ext/class.rb

@@ -0,0 +1,139 @@
+require 'cloudist/core_ext/kernel'
+require 'cloudist/core_ext/module'
+
+# Extracted from ActiveSupport 3.0
+class Class
+  
+  # Taken from http://coderrr.wordpress.com/2008/04/10/lets-stop-polluting-the-threadcurrent-hash/
+  def thread_local_accessor name, options = {}
+    m = Module.new
+    m.module_eval do
+      class_variable_set :"@@#{name}", Hash.new {|h,k| h[k] = options[:default] }
+    end
+    m.module_eval %{
+      FINALIZER = lambda {|id| @@#{name}.delete id }
+
+      def #{name}
+        @@#{name}[Thread.current.object_id]
+      end
+
+      def #{name}=(val)
+        ObjectSpace.define_finalizer Thread.current, FINALIZER  unless @@#{name}.has_key? Thread.current.object_id
+        @@#{name}[Thread.current.object_id] = val
+      end
+    }
+
+    class_eval do
+      include m
+      extend m
+    end
+  end
+  
+  
+  # Declare a class-level attribute whose value is inheritable by subclasses.
+  # Subclasses can change their own value and it will not impact parent class.
+  #
+  #   class Base
+  #     class_attribute :setting
+  #   end
+  #
+  #   class Subclass < Base
+  #   end
+  #
+  #   Base.setting = true
+  #   Subclass.setting            # => true
+  #   Subclass.setting = false
+  #   Subclass.setting            # => false
+  #   Base.setting                # => true
+  #
+  # In the above case as long as Subclass does not assign a value to setting
+  # by performing <tt>Subclass.setting = _something_ </tt>, <tt>Subclass.setting</tt>
+  # would read value assigned to parent class. Once Subclass assigns a value then
+  # the value assigned by Subclass would be returned.
+  #
+  # This matches normal Ruby method inheritance: think of writing an attribute
+  # on a subclass as overriding the reader method. However, you need to be aware
+  # when using +class_attribute+ with mutable structures as +Array+ or +Hash+.
+  # In such cases, you don't want to do changes in places but use setters:
+  #
+  #   Base.setting = []
+  #   Base.setting                # => []
+  #   Subclass.setting            # => []
+  #
+  #   # Appending in child changes both parent and child because it is the same object:
+  #   Subclass.setting << :foo
+  #   Base.setting               # => [:foo]
+  #   Subclass.setting           # => [:foo]
+  #
+  #   # Use setters to not propagate changes:
+  #   Base.setting = []
+  #   Subclass.setting += [:foo]
+  #   Base.setting               # => []
+  #   Subclass.setting           # => [:foo]
+  #
+  # For convenience, a query method is defined as well:
+  #
+  #   Subclass.setting?       # => false
+  #
+  # Instances may overwrite the class value in the same way:
+  #
+  #   Base.setting = true
+  #   object = Base.new
+  #   object.setting          # => true
+  #   object.setting = false
+  #   object.setting          # => false
+  #   Base.setting            # => true
+  #
+  # To opt out of the instance writer method, pass :instance_writer => false.
+  #
+  #   object.setting = false  # => NoMethodError
+  def class_attribute(*attrs)
+    instance_writer = !attrs.last.is_a?(Hash) || attrs.pop[:instance_writer]
+
+    attrs.each do |name|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{name}() nil end
+        def self.#{name}?() !!#{name} end
+
+        def self.#{name}=(val)
+          singleton_class.class_eval do
+            remove_possible_method(:#{name})
+            define_method(:#{name}) { val }
+          end
+
+          if singleton_class?
+            class_eval do
+              remove_possible_method(:#{name})
+              def #{name}
+                defined?(@#{name}) ? @#{name} : singleton_class.#{name}
+              end
+            end
+          end
+          val
+        end
+
+        remove_method :#{name} if method_defined?(:#{name})
+        def #{name}
+          defined?(@#{name}) ? @#{name} : self.class.#{name}
+        end
+
+        def #{name}?
+          !!#{name}
+        end
+      RUBY
+
+      attr_writer name if instance_writer
+    end
+  end
+
+  private
+  def singleton_class?
+    # in case somebody is crazy enough to overwrite allocate
+    allocate = Class.instance_method(:allocate)
+    # object.class always points to a real (non-singleton) class
+    allocate.bind(self).call.class != self
+  rescue TypeError
+    # MRI/YARV/JRuby all disallow creating new instances of a singleton class
+    true
+  end
+end

data/lib/cloudist/core_ext/kernel.rb

@@ -0,0 +1,13 @@
+module Kernel
+  # Returns the object's singleton class.
+  def singleton_class
+    class << self
+      self
+    end
+  end unless respond_to?(:singleton_class) # exists in 1.9.2
+
+  # class_eval on an object acts like singleton_class.class_eval.
+  def class_eval(*args, &block)
+    singleton_class.class_eval(*args, &block)
+  end
+end

data/lib/cloudist/core_ext/module.rb

@@ -0,0 +1,11 @@
+class Module
+  def remove_possible_method(method)
+    remove_method(method)
+  rescue NameError
+  end
+
+  def redefine_method(method, &block)
+    remove_possible_method(method)
+    define_method(method, &block)
+  end
+end

data/lib/cloudist/encoding.rb

@@ -0,0 +1,13 @@
+module Cloudist
+  module Encoding
+    def encode(message)
+      Marshal.dump(message)
+    end
+
+    def decode(message)
+      raise ArgumentError, "First argument can't be nil" if message.nil?
+      return message unless message.is_a?(String)
+      Marshal.load(message)
+    end
+  end
+end

data/lib/cloudist/errors.rb

@@ -3,4 +3,6 @@ module Cloudist
   class BadPayload < Error; end
   class EnqueueError < Error; end
   class StaleHeadersError < BadPayload; end
+  class UnknownReplyTo < RuntimeError; end
+  class ExpiredMessage < RuntimeError; end
 end

data/lib/cloudist/job.rb

@@ -1,8 +1,16 @@
 module Cloudist
   class Job
-    attr_reader :payload
+    attr_reader :payload, :reply_queue
+    
     def initialize(payload)
       @payload = payload
+      
+      if payload.reply_to
+        @reply_queue = ReplyQueue.new(payload.reply_to)
+        reply_queue.setup
+      else
+        @reply_queue = nil
+      end
     end
     
     def id
@@ -13,34 +21,34 @@ module Cloudist
       payload.body
     end
     
+    def body
+      data
+    end
+    
     def log
       Cloudist.log
     end
     
     def cleanup
-      
+      # :noop
     end
     
     def reply(body, headers = {}, options = {})
+      raise ArgumentError, "Reply queue not ready" unless reply_queue
+      
       options = {
         :echo => false
       }.update(options)
       
       headers = {
-        :message_id => payload.headers[:message_id],
+        :message_id => payload.id,
         :message_type => "reply"
       }.update(headers)
       
-      # Echo the payload back
-      # body.merge!(payload.body) if options[:echo] == true
-      
       reply_payload = Payload.new(body, headers)
+      published_headers = reply_queue.publish(reply_payload)
       
-      reply_queue = ReplyQueue.new(payload.reply_to)
-      reply_queue.setup
-      published_headers = reply_queue.publish_to_q(reply_payload)
-      
-      log.debug("Replying: #{body.inspect} HEADERS: #{headers.inspect}")
+      reply_payload
     end
     
     # Sends a progress update
@@ -51,23 +59,18 @@ module Cloudist
     end
     
     def event(event_name, event_data = {}, options = {})
-      event_data = {} if event_data.nil?
+      event_data ||= {}
       reply(event_data, {:event => event_name, :message_type => 'event'}, options)
     end
     
     def safely(&blk)
-      # begin
       yield
     rescue Exception => e
       handle_error(e)
-      # end
-      # result
     end
     
-    # This will transfer the Exception object to the client
     def handle_error(e)
-      # reply({:exception_class => e.class.name, :message => e.message, :backtrace => e.backtrace}, {:message_type => 'error'})
-      reply({:exception => e}, {:message_type => 'error'})
+      reply({:exception => e.class.name.to_s, :message => e.message.to_s, :backtrace => e.backtrace}, {:message_type => 'error'})
     end
     
     def method_missing(meth, *args, &blk)

data/lib/cloudist/listener.rb

@@ -1,79 +1,133 @@
+require "active_support"
 module Cloudist
   class Listener
-    include Cloudist::CallbackMethods
+    include ActiveSupport::Callbacks
     
-    attr_reader :job_queue_name, :job_id, :callbacks
+    attr_reader :job_queue_name, :payload
+    class_attribute :job_queue_names
     
-    @@valid_callbacks = ["event", "progress", "reply", "update", "error"]
-    
-    def initialize(job_or_queue_name)
-      @callbacks = {}
+    class << self
+      def listen_to(*job_queue_names)
+        self.job_queue_names = job_queue_names.map { |q| Utils.reply_prefix(q) }
+      end
       
-      if job_or_queue_name.is_a?(Cloudist::Job)
-        @job_queue_name = Utils.reply_prefix(job_or_queue_name.payload.headers[:master_queue])
-        @job_id = job_or_queue_name.id
-      elsif job_or_queue_name.is_a?(String)
-        @job_queue_name = Utils.reply_prefix(job_or_queue_name)
-        @job_id = nil
-      else
-        raise ArgumentError, "Invalid listener type, accepts job queue name or Cloudist::Job instance"
+      def subscribe(queue_name)
+        raise RuntimeError, "You can't subscribe until EM is running" unless EM.reactor_running?
+                
+        reply_queue = Cloudist::ReplyQueue.new(queue_name)
+        reply_queue.subscribe do |request|
+          instance = Cloudist.listener_instances[queue_name] ||= new
+          instance.handle_request(request)
+        end
+        
+        queue_name
+      end
+      
+      def before(*args, &block)
+        set_callback(:call, :before, *args, &block)
+      end
+
+      def after(*args, &block)
+        set_callback(:call, :after, *args, &block)
       end
     end
     
-    def subscribe(&block)
-      reply_queue = Cloudist::ReplyQueue.new(job_queue_name)
-      reply_queue.setup(job_id) if job_id
+    define_callbacks :call, :rescuable => true
+    
+    def handle_request(request)
+      @payload = request.payload
+      key = [payload.message_type.to_s, payload.headers[:event]].compact.join(':')
       
-      self.instance_eval(&block)
+      meth, *args = handle_key(key)
       
-      reply_queue.subscribe do |request|
-        payload = request.payload
-        
-        key = [payload.message_type.to_s, payload.headers[:event]].compact.join(':')
-        
-        # If we want to get a callback on every event, do it here
-        if callbacks.has_key?('everything')
-          callbacks['everything'].each do |c|
-            c.call(payload)
-          end
-        end
-        
-        if callbacks.has_key?('error')
-          callbacks['error'].each do |c|
-            # c.call(payload)
-            
-          end
-        end
-        
-        if callbacks.has_key?(key)
-          callbacks_to_call = callbacks[key]
-          callbacks_to_call.each do |c|
-            c.call(payload)
-          end
+      if meth.present? && self.respond_to?(meth)
+        if method(meth).arity <= args.size
+          call(meth, args.first(method(meth).arity))
+        else
+          raise ArgumentError, "Unable to fire callback (#{meth}) because we don't have enough args"
         end
       end
     end
     
-    def everything(&blk)
-      (@callbacks['everything'] ||= []) << Callback.new(blk)
+    def id
+      payload.id
     end
     
-    def method_missing(meth, *args, &blk)
-      if @@valid_callbacks.include?(meth.to_s)
+    def data
+      payload.body
+    end
+    
+    def handle_key(key)
+      key = key.split(':', 2)
+      return [nil, nil] if key.empty?
+      
+      method_and_args = [key.shift.to_sym]
+      case method_and_args[0]
+      when :event
+        if key.size > 0 && self.respond_to?(key.first)
+          method_and_args = [key.shift]
+        end
+        method_and_args << key
+        
+      when :progress
+        method_and_args << payload.progress
+        method_and_args << payload.description
+        
+      when :runtime
+        method_and_args << payload.runtime
         
-        # callback should in format of "event:started" or "progress"
-        key = [meth.to_s, args.shift].compact.join(':')
+      when :reply
         
-        case meth.to_sym
-        when :error
-          (@callbacks[key] ||= []) << ErrorCallback.new(blk)
+      when :update
+        
+      when :error
+        # method_and_args << Cloudist::SafeError.new(payload)
+        method_and_args << Hashie::Mash.new(payload.body)
+        
+      when :log
+        method_and_args << payload.message
+        method_and_args << payload.level
+        
+      else
+        method_and_args << data if method(method_and_args[0]).arity == 1
+      end
+      
+      return method_and_args
+    end
+    
+    def call(meth, args)
+      run_callbacks :call do
+        if args.empty?
+          send(meth)
         else
-          (@callbacks[key] ||= []) << Callback.new(blk)
+          send(meth, *args)
         end
-      else
-        super
       end
     end
     
+    def progress(pct)
+      # :noop
+    end
+    
+    def runtime(seconds)
+      # :noop
+    end
+    
+    def event(type)
+      # :noop
+    end
+    
+    def log(message, level)
+      # :noop
+    end
+    
+    def error(e)
+      # :noop
+    end
+    
+  end
+  
+  class GenericListener < Listener
+    
   end
 end