maestro_common 0.0.2 → 0.0.3

data/lib/maestro_common/common.rb

@@ -1,2 +1,2 @@
-require File.join(File.dirname(__FILE__), 'utils', 'retryable.rb')
-require File.join(File.dirname(__FILE__), 'helpers', 'mq_helper.rb')
+require File.join(File.dirname(__FILE__), 'utils', 'retryable')
+require File.join(File.dirname(__FILE__), 'mq', 'messenger')

data/lib/maestro_common/mq/messenger.rb

@@ -0,0 +1,254 @@
+# Copyright 2011(c) MaestroDev.  All rights reserved.
+require File.join(File.dirname(__FILE__), '..', 'helpers', 'mq_helper')
+
+module Maestro
+  class MessageSendError < StandardError
+  end
+
+  class Messenger
+    VALID_QUEUE_REGEX = "^/(?:queue|topic)/[A-Za-z0-9_]*$"
+
+    DEFAULT_SEND_OPTIONS = { :persistent => true, :content_type => 'application/json' }
+    DEFAULT_SYNC_TIMEOUT = 5
+    DEFAULT_CUSTOM_TEXT = 'message'
+
+    attr_accessor :from_name, :debug
+    attr_reader :seq, :queues
+
+    class Message < Hash
+      def initialize(msg_type, content, reply_to = nil)
+        super()
+        self['__msg_type__'] = msg_type
+        self['__msg_content__'] = content
+        self['__msg_reply_to__'] = reply_to if reply_to
+      end
+    end
+
+    class Queue
+      attr_accessor :name, :default_handler, :handlers, :messenger, :connected, :opts, :use_eventmachine
+
+      # Minimum requirements - a name, and a handler for messages we don't know about
+      def initialize(name, default_handler = nil, opts = {})
+        raise ArgumentError, "#{name} cannot be nil" unless name
+        raise ArgumentError, "#{name} must match the following regex #{VALID_QUEUE_REGEX}, '#{name}' does not" unless name.match(/#{VALID_QUEUE_REGEX}/)
+
+        self.handlers = {}
+        self.connected = false
+        self.default_handler = default_handler
+        self.name = name
+        self.opts = opts
+        self.use_eventmachine = true
+
+        if default_handler
+          register_handler(default_handler)
+        else
+          Maestro.log.info "No default handler for queue '#{name}'.  Unknown messages will be dropped"
+        end
+      end
+
+      def register_handler(handler, msg_types = nil)
+        msg_types = handler.get_handled_message_types unless msg_types
+
+        if msg_types && !msg_types.empty?
+          msg_types.each do |t|
+            handlers[t] = handler
+            Maestro.log.debug "Registering message type '#{t}' to handler '#{handler.class.name}' on queue #{name}"
+          end
+        else
+          Maestro.log.debug "No message types registered for queue '#{name}' all messages will be #{default_handler ? 'sent to "on_unhandled_message"' : 'dropped'}"
+        end
+      end
+
+      def send_message_async(message, options = DEFAULT_SEND_OPTIONS, &block)
+        messenger.send_message_async(name, message, options, block)
+      end
+      alias :send_message :send_message_async
+
+      def send_message_sync(message, timeout = DEFAULT_SYNC_TIMEOUT, options = DEFAULT_SEND_OPTIONS, &block)
+        messenger.send_message_sync(name, message, timeout, options, block)
+      end
+
+      def handle_incoming_message(message)
+        # All consumers expect message data to be json and parse... maybe just parse it here and pass parsed data
+        # then if we use different encoding noone will be any the wiser
+        begin
+          Maestro.log.debug "Received Message #{message.body}" if messenger.debug
+
+          # Only pass messages that have not expired
+          now = Time.now.to_i * 1000
+          expiration = message.headers['expires'].to_i
+
+          if (expiration > 0 && now > expiration)
+            timing = "Message expired at: #{expiration} [#{Time.at expiration/1000}], Current time: #{now} [#{Time.at now/1000}]"
+            Maestro.log.warn "Skipping agent queue expired message. #{timing}: #{message.body}"
+            # drop message
+          else
+            hash = JSON.parse(message.body)
+            msg_type = hash['__msg_type__'] || '-legacy-'
+            hash['__msg_from__'] = name
+            handler = handlers[msg_type]
+
+            if handler && handler.respond_to?(:on_incoming_message)
+              # Depending on arity, send either (self, type, content) or (self, type, content, raw)
+              case handler.method(:on_incoming_message).arity
+              when 3
+                handler.on_incoming_message(self, msg_type, hash['__msg_content__'])
+              when 4
+                handler.on_incoming_message(self, msg_type, hash['__msg_content__'], hash)
+              end
+            else
+              if default_handler && default_handler.respond_to?(:on_unhandled_message)
+                default_handler.on_unhandled_message(self, msg_type, hash['__msg_content__'], hash)
+              else
+                Maestro.log.warn "Dumping unhandled '#{msg_type}' message (no default handler): #{hash}"
+              end
+            end
+
+            Maestro.log.debug("Processed #{msg_type}: #{message.body}") if messenger.debug
+          end
+        rescue Exception => e
+          # something happened executing processing the message/running the plugin
+          backtrace = e.backtrace.join("\n")
+          # set the error with the exception message and backtrace
+          Maestro.log.error "Error processing message - #{e.class}:#{e}\n#{backtrace}"
+        ensure
+          if opts && opts[:ack] == 'client'
+            Maestro::MQHelper.connection.ack(message)
+          end
+        end
+      end
+
+      # Override attr setter so we can resubscribe, etc
+      def name=(name)
+        if !@name || @name != name
+          disconnect
+          @name = name
+          connect
+        end
+      end
+
+      def messenger=(messenger)
+        disconnect unless messenger
+        @messenger = messenger
+        connect
+      end
+
+      def connect
+        if messenger
+          # If eventmachine enabled will use it to defer delivery so we can receive the message and continue with life
+          # That can be an issue sometimes as different threads may execute at different rates, causing unintentional
+          # bursts of chronometric radiation that can cause messages to appear to execute in non-sequential order.
+          # (Actually they are, but since multiple may be executing in parallel it can have unintended consequences)
+          # Set the 'use_eventmachine' property of the queue connection to 'false' to ensure message processing completes
+          # in the order of reception.  This will effectively block incoming messages, so the consequences of that should
+          # be taken into account.
+          Maestro::MQHelper.subscribe(@name, opts) { |message| use_eventmachine ? EventMachine.defer { handle_incoming_message(message) } : handle_incoming_message(message) } unless connected?
+          self.connected = true
+        end
+      end
+
+      def disconnect
+        Maestro::MQHelper.unsubscribe(@name) if @name && connected?
+        self.connected = false
+      end
+
+      def connected?
+        return connected
+      end
+    end
+
+
+    def initialize
+      @lock = Monitor.new
+      @seq = 0
+      @queues = {}
+      @from_name =
+      Maestro::MQHelper.connect
+    end
+
+    def connected?
+      return MQHelper.connection && MQHelper.connection.connected?
+    end
+
+    def register_queue(queue)
+      queues[queue.name] = queue
+      queue.messenger = self
+
+      return queue
+    end
+
+    def deregister_queue(queue)
+      queue = queues[queue] if queue.is_a?(String)
+
+      if queue
+        queues.delete(queue.name)
+        queue.destroy
+      end
+    end
+
+    def stop
+      queues.each { |q| deregister_queue(queue) }
+      MQHelper.disconnect
+    end
+
+    def reconnect
+      MQHelper.reconnect unless connected?
+    end
+
+    def disconnect
+      MQHelper.disconnect if connected?
+    end
+
+    def send_message_async(destination_queue, message, options = DEFAULT_SEND_OPTIONS, &block)
+      my_seq = seq
+
+      message['__msg_seq__'] = my_seq
+
+      custom_text = message.has_key?('__msg_type__') ? message['__msg_type__'] : DEFAULT_CUSTOM_TEXT
+
+      Maestro.log.debug "[seq #{my_seq}] Sending #{custom_text}" if debug
+
+      Maestro::MQHelper.connection.send( destination_queue, message.to_json, options ) do |r|
+        Maestro.log.debug "[seq #{my_seq}] Sent #{custom_text} to '#{destination_queue}'" if debug
+
+        yield(r) if block
+      end
+    end
+    alias :send_message :send_message_async
+
+    def send_message_sync(destination_queue, message, timeout = DEFAULT_SYNC_TIMEOUT, options = DEFAULT_SEND_OPTIONS, &block)
+      ackd = false
+      rr = nil
+
+      send_message_async(destination_queue, message, options) do |r|
+        rr = r
+        ackd = true
+      end
+
+      begin
+        Timeout::timeout(timeout) do
+          while !ackd
+            sleep 0.25
+          end
+
+          ackd = true
+
+          yield(rr) if block
+        end
+      rescue Timeout::Error
+        raise MessageSendError, "Message ##{message['__msg_seq__']} not ack'd by MQ"
+      end
+
+      return ackd
+    end
+
+    def seq
+      @lock.synchronize do
+        @seq += 1
+
+        return @seq
+      end
+    end
+  end
+
+end

data/lib/maestro_common/version.rb

@@ -1,5 +1,5 @@
 module Maestro
   module Common
-    VERSION = '0.0.2'
+    VERSION = '0.0.3'
   end
 end

data/maestro_common.gemspec

@@ -22,6 +22,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'logging', '>= 1.8.0'
   spec.add_dependency 'rubyzip', '>= 0.9.8'
   spec.add_dependency 'json', '>= 1.4.6'
+  spec.add_dependency 'eventmachine', ">=0.12.10"
 
   spec.add_development_dependency 'bundler', '>= 1.3'
   spec.add_development_dependency 'rake'

data/spec/retryable_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Maestro::Utils do
+
+  describe '#retryable' do
+    
+    it 'should retry the correct number of times' do
+      # Can't do this until the logging is sorted
+#      attempts = 0
+#      Maestro::Utils.retryable({:tries => 5, :sleep => 1}) do
+#        attempts += 1
+#        raise 'A ruckus'
+#      end
+#
+#      attempts.should == 5
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'rspec'
+require 'logger'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib') unless $LOAD_PATH.include?(File.dirname(__FILE__) + '/../lib')
+
+require File.join('maestro_common', 'common')
+
+RSpec.configure do |config|
+
+end
+
+
+

metadata

@@ -2,7 +2,7 @@
 name: maestro_common
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
   - Doug Henderson
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-07-16 00:00:00 Z
+date: 2013-08-19 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: onstomp
@@ -57,29 +57,29 @@ dependencies:
     prerelease: false
     type: :runtime
   - !ruby/object:Gem::Dependency 
-    name: bundler
+    name: eventmachine
     version_requirements: &id005 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
-            version: "1.3"
+            version: 0.12.10
     requirement: *id005
     prerelease: false
-    type: :development
+    type: :runtime
   - !ruby/object:Gem::Dependency 
-    name: rake
+    name: bundler
     version_requirements: &id006 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
-            version: "0"
+            version: "1.3"
     requirement: *id006
     prerelease: false
     type: :development
   - !ruby/object:Gem::Dependency 
-    name: jruby-openssl
+    name: rake
     version_requirements: &id007 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
@@ -90,16 +90,27 @@ dependencies:
     prerelease: false
     type: :development
   - !ruby/object:Gem::Dependency 
-    name: rspec
+    name: jruby-openssl
     version_requirements: &id008 !ruby/object:Gem::Requirement 
       none: false
       requirements: 
         - - ">="
           - !ruby/object:Gem::Version 
-            version: 2.13.0
+            version: "0"
     requirement: *id008
     prerelease: false
     type: :development
+  - !ruby/object:Gem::Dependency 
+    name: rspec
+    version_requirements: &id009 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            version: 2.13.0
+    requirement: *id009
+    prerelease: false
+    type: :development
 description: A bunch of utility classes that are used in multiple places
 email: 
   - dhenderson@maestrodev.com
@@ -118,9 +129,12 @@ files:
   - lib/maestro_common/common.rb
   - lib/maestro_common/helpers/mq_helper.rb
   - lib/maestro_common/logging/maestro_logging.rb
+  - lib/maestro_common/mq/messenger.rb
   - lib/maestro_common/utils/retryable.rb
   - lib/maestro_common/version.rb
   - maestro_common.gemspec
+  - spec/retryable_spec.rb
+  - spec/spec_helper.rb
 homepage: https://github.com/maestrodev/maestro-ruby-common
 licenses: 
   - Apache 2.0
@@ -154,5 +168,6 @@ rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Maestro common classes
-test_files: []
-
+test_files: 
+  - spec/retryable_spec.rb
+  - spec/spec_helper.rb