cloudist 0.4.4 → 0.5.0

data/lib/cloudist/listener.rb

@@ -2,27 +2,27 @@ require "active_support"
 module Cloudist
   class Listener
     include ActiveSupport::Callbacks
-    
+
     attr_reader :job_queue_name, :payload
     class_attribute :job_queue_names
-    
+
     class << self
       def listen_to(*job_queue_names)
         self.job_queue_names = job_queue_names.map { |q| Utils.reply_prefix(q) }
       end
-      
+
       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
@@ -31,16 +31,16 @@ module Cloudist
         set_callback(:call, :after, *args, &block)
       end
     end
-    
+
     define_callbacks :call, :rescuable => true
-    
+
     def handle_request(request)
       @payload = request.payload
       key = [payload.message_type.to_s, payload.headers[:event]].compact.join(':')
-      
+
       meth, *args = handle_key(key)
-      
-      if meth.present? && self.respond_to?(meth)
+
+      if meth && self.respond_to?(meth)
         if method(meth).arity <= args.size
           call(meth, args.first(method(meth).arity))
         else
@@ -48,19 +48,19 @@ module Cloudist
         end
       end
     end
-    
+
     def id
       payload.id
     end
-    
+
     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
@@ -68,33 +68,33 @@ module Cloudist
           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
-        
+
       when :reply
-        
+
       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?
@@ -104,30 +104,30 @@ module Cloudist
         end
       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

data/lib/cloudist/message.rb

@@ -1,49 +1,49 @@
 module Cloudist
   class Message
     include Cloudist::Encoding
-    
+
     attr_reader :body, :headers, :id, :timestamp
-    
+
     # Expects body to be decoded
     def initialize(body, headers = {})
       @body = Hashie::Mash.new(body.dup)
-      
+
       @id ||= headers[:message_id] || headers[:id] && headers.delete(:id) || UUID.generate
       @headers = Hashie::Mash.new(headers.dup)
-      
+
       @timestamp = Time.now.utc.to_f
-      
+
       update_headers(headers)
     end
-    
+
     alias_method :data, :body
-    
+
     def update_headers(new_headers = {})
       update_headers!
       headers.merge!(new_headers)
     end
-    
+
     def update_headers!
       headers[:ttl] ||= Cloudist::DEFAULT_TTL
       headers[:timestamp] = timestamp
       headers[:message_id] ||= id
       headers[:message_type] = 'message'
       headers[:queue_name] ||= 'test'
-      
+
       headers.each { |k,v| headers[k] = v.to_s }
     end
-    
+
     # Convenience method for replying
     # Constructs a reply message and publishes it
     def reply(body, reply_headers = {})
       raise RuntimeError, "Cannot reply to an unpublished message" unless published?
-      
+
       msg = Message.new(body, reply_headers)
       msg.set_reply_header
       reply_q = Cloudist::ReplyQueue.new(headers[:queue_name])
       msg.publish(reply_q)
     end
-    
+
     # Publishes this message to the exchange or queue
     # Queue should be a Cloudist::Queue object responding to #publish
     def publish(queue)
@@ -53,45 +53,45 @@ module Cloudist
       update_headers!
       queue.publish(self)
     end
-    
+
     def update_published_date!
       headers[:published_on] = Time.now.utc.to_f
     end
-    
+
     # This is so we can reply back to the sender
     def set_queue_name_header(queue)
       update_headers(:queue_name => queue.name)
     end
-    
+
     def published?
       @published ||= !!@headers.published_on
     end
-    
+
     def created_at
       headers.timestamp ? Time.at(headers.timestamp.to_f) : timestamp
     end
-    
+
     def published_at
       headers[:published_on] ? Time.at(headers[:published_on].to_f) : timestamp
     end
-    
+
     def latency
       (published_at.to_f - created_at.to_f)
     end
-    
+
     def encoded
       [encode(body), {:headers => headers}]
     end
-    
+
     def inspect
       "<#{self.class.name} id=#{id}>"
     end
-    
+
     private
-    
+
     def set_reply_header
       headers[:message_type] = 'reply'
     end
-    
+
   end
 end

data/lib/cloudist/messaging.rb

@@ -1,29 +1,29 @@
 module Cloudist
   autoload :Singleton, 'singleton'
-  
+
   class Messaging
     include Singleton
-    
+
     class << self
-      
+
       def active_queues
         instance.active_queues
       end
-      
+
       def add_queue(queue)
         (instance.active_queues ||= {}).merge!({queue.name.to_s => queue})
         instance.active_queues
       end
-      
+
       def remove_queue(queue_name)
         (instance.active_queues ||= {}).delete(queue_name.to_s)
         instance.active_queues
       end
     end
-    
+
     attr_accessor :active_queues
-    
-    
-    
+
+
+
   end
 end

data/lib/cloudist/payload.rb

@@ -2,81 +2,81 @@ module Cloudist
   class Payload
     include Utils
     include Encoding
-    
+
     attr_reader :body, :headers, :amqp_headers, :timestamp
-    
+
     def initialize(body, headers = {})
       @published = false
       @timestamp = Time.now.to_f
-      
+
       body = decode(body) if body.is_a?(String)
       @body = Hashie::Mash.new(decode(body))
       @headers = Hashie::Mash.new(headers)
       @amqp_headers = {}
       # puts "Initialised Payload: #{id}"
-      
+
       parse_headers!
     end
-    
+
     def find_or_create_id
-      if headers["message_id"].present?
+      if headers["message_id"]
         headers.message_id
       else
         UUID.generate
       end
     end
-    
+
     def id
       find_or_create_id
     end
-    
+
     def to_a
       [encode(body), {:headers => encoded_headers}]
     end
-    
+
     def parse_headers!
       headers[:published_on] ||= body.delete("timestamp") || timestamp
       headers[:message_type] ||= body.delete("message_type") || 'reply'
-      
+
       headers[:ttl] ||= Cloudist::DEFAULT_TTL
       headers[:message_id] = id
-      
+
       headers[:published_on] = headers[:published_on].to_f
-      
+
       headers[:ttl] = headers[:ttl].to_i rescue -1
       headers[:ttl] = -1 if headers[:ttl] == 0
-      
+
       # If this payload was received with a timestamp,
       # we don't want to override it on #timestamp
       if timestamp > headers[:published_on]
         @timestamp = headers[:published_on]
       end
-      
+
       headers
     end
-    
+
     def encoded_headers
       h = headers.dup
       h.each { |k,v| h[k] = v.to_s }
       return h
     end
-    
+
     def set_reply_to(queue_name)
       headers[:reply_to] = reply_prefix(queue_name)
     end
-    
+
     def reply_to
       headers.reply_to
     end
-    
+
     def message_type
       headers.message_type
     end
-    
+
     def [](key)
       self.body[key.to_s]
     end
-    
+
     def method_missing(meth, *args, &blk)
       if body.has_key?(meth.to_s)
         return body[meth]
@@ -86,6 +86,6 @@ module Cloudist
         super
       end
     end
-    
+
   end
-end
+end

data/lib/cloudist/payload_old.rb

@@ -1,55 +1,55 @@
 module Cloudist
   class Payload
     include Utils
-    
+
     attr_reader :body, :publish_opts, :headers, :timestamp
 
     def initialize(body, headers = {}, publish_opts = {})
       @publish_opts, @headers = publish_opts, Hashie::Mash.new(headers)
       @published = false
-      
+
       body = parse_message(body) if body.is_a?(String)
-      
+
       # raise Cloudist::BadPayload, "Expected Hash for payload" unless body.is_a?(Hash)
-      
+
       @timestamp = Time.now.to_f
-      
+
       @body = body
       # Hashie::Mash.new(body)
-      
+
       update_headers
     end
 
     # Return message formatted as JSON and headers ready for transport in array
     def formatted
       update_headers
-      
+
       [encode_message(body), publish_opts]
     end
-    
+
     def id
       @id ||= event_hash.to_s
     end
-    
+
     def id=(new_id)
       @id = new_id.to_s
       update_headers
     end
-    
+
     def frozen?
       headers.frozen?
     end
-    
+
     def freeze!
       headers.freeze
       body.freeze
     end
-    
+
     def update_headers
       headers = extract_custom_headers
       (publish_opts[:headers] ||= {}).merge!(headers)
     end
-    
+
     def extract_custom_headers
       raise StaleHeadersError, "Headers cannot be changed because payload has already been published" if published?
       headers[:published_on] ||= body.is_a?(Hash) && body.delete(:published_on) || Time.now.utc.to_i
@@ -60,19 +60,19 @@ module Cloudist
 
       # this value should be unique for each published/received message pair
       headers[:message_id] ||= id
-      
+
       # We use JSON for message transport exclusively
       # headers[:content_type] ||= 'application/json'
-      
+
       # headers[:headers][:message_type] = 'event'
        # ||= body.delete('message_type') || 'reply'
-      
+
       # headers[:headers] = custom_headers
-      
+
       # some strange behavior with integers makes it better to
       # convert all amqp headers to strings to avoid any problems
       headers.each { |k,v| headers[k] = v.to_s }
-      
+
       headers
     end
 
@@ -88,59 +88,59 @@ module Cloudist
 
       h
     end
-    
+
     def set_reply_to(queue_name)
       headers["reply_to"] = reply_name(queue_name)
       set_master_queue_name(queue_name)
     end
-    
+
     def set_master_queue_name(queue_name)
-      headers[:master_queue] = queue_name 
+      headers[:master_queue] = queue_name
     end
-    
+
     def reply_name(queue_name)
       # "#{queue_name}.#{id}"
       Utils.reply_prefix(queue_name)
     end
-    
+
     def reply_to
       headers["reply_to"]
     end
-    
+
     def message_type
       headers["message_type"]
     end
-    
+
     def event_hash
       @event_hash ||= headers["event_hash"] || create_event_hash
     end
-    
+
     def create_event_hash
       # s = Time.now.to_s + object_id.to_s + rand(100).to_s
       # Digest::MD5.hexdigest(s)
       UUID.generate
     end
-    
+
     def parse_message(raw)
       # return { } unless raw
       # decode_json(raw)
       decode_message(raw)
     end
-    
+
     def [](key)
       body[key]
     end
-    
+
     def published?
       @published == true
     end
-    
+
     def publish
       return if published?
       @published = true
       freeze!
     end
-    
+
     def method_missing(meth, *args, &blk)
       if body.is_a?(Hash) && body.has_key?(meth)
         return body[meth]
@@ -150,6 +150,6 @@ module Cloudist
         super
       end
     end
-    
+
   end
-end
+end