smith 0.5.12 → 0.5.13.1

data/lib/smith/commands/smithctl/push.rb

@@ -6,79 +6,98 @@ module Smith
   module Commands
     class Push < CommandBase
       def execute
+        push do |ret|
+          responder.succeed(ret)
+        end
+      end
+
+      private
+
+      def push(&blk)
         if target.size == 0
-          responder.value("No queue specified. Please specify a queue.")
-          Smith.stop(true)
+          blk.call("No queue specified. Please specify a queue.")
         else
           begin
-            messages = case
-                   when options[:message_given]
-                     options[:message]
-                   when options[:file_given]
-                     responder.value("--number option cannot be used with the --file option.") if options[:number_given]
-
-                     file = Pathname.new(options[:file])
-                     if file.exist?
-                       file.read
-                     else
-                       responder.value("File does not exist: #{file.display}")
-                     end
-                   else
-                     responder.value("--number option cannot be used when reading messages from standard in.") if options[:number_given]
-                     STDIN.read
-                   end
-
-            if messages.nil? || messages && messages.empty?
-              responder.value("Message must be empty.")
-            end
-
-            # This is starting to get a bit messy. The iterator is being used
-            # for two purposes: the first is to send multiple messages, the
-            # second is send the same message multiple times.
-            # TODO Clean this up.
-
-            Messaging::Sender.new(target.first, :auto_delete => options[:dynamic], :persistent => true, :nowait => false, :strict => true).ready do |sender|
-              work = proc do |message,iter|
-                m = (options[:number_given]) ? messages : message
-
-                sender.publish(json_to_payload(m, options[:type])) do
-                  iter.next
+            Messaging::Sender.new(target.first, :auto_delete => options[:dynamic], :persistent => true, :nowait => false, :strict => true) do |sender|
+              if options[:reply]
+                timeout = Smith::Messaging::Timeout.new(options[:timeout]) do |message_id|
+                  blk.call("Timed out after: #{options[:timeout]} seconds for message: #{options[:message]}: message_id: #{message_id}")
                 end
-              end
 
-              done = proc do
-                responder.value
-              end
+                sender.on_reply(:timeout => timeout) { |payload| blk.call(payload.to_hash) }
+                sender.publish(json_to_payload(options[:message], options[:type]))
+              else
+                on_work = ->(message, iter) do
+                  sender.publish(json_to_payload(message, options[:type])) do
+                    iter.next
+                  end
+                end
 
-              data = (options[:number_given]) ? 0..options[:number] - 1 : messages.split("\n")
+                on_done = -> { blk.call("") }
 
-              EM::Iterator.new(data).each(work, done)
+                iterator.each(on_work, on_done)
+              end
             end
           rescue MultiJson::DecodeError => e
-            responder.value(e)
-            Smith.stop
+            blk.call(e)
           end
         end
       end
 
-      private
-
-      def json_to_payload(data, type)
-        ACL::Payload.new(type.to_sym).content do |m|
-          MultiJson.load(data, :symbolize_keys => true).each do |k,v|
-            m.send("#{k}=".to_sym, v)
+      # Return a interator that can iterate over whatever the input is.
+      def iterator
+        case
+        when options[:message_given]
+          if options[:number_given]
+            EM::Iterator.new([options[:message]] * options[:number])
+          else
+            EM::Iterator.new([options[:message]])
           end
+        when options[:file_given]
+          FileReader.new(options[:file])
+        else
+          raise ArgumentError, "--number option cannot be used when reading messages from standard in." if options[:number_given]
+          FileReader.new(STDIN)
         end
       end
 
+      def json_to_payload(data, type)
+        ACL::Factory.create(type, MultiJson.load(data, :symbolize_keys => true))
+      end
+
       def options_spec
         banner "Send a message to a queue. The ACL can also be specified."
 
         opt :type,    "message type", :type => :string, :default => 'default', :short => :t
-        opt :message, "the message, as json", :type => :string, :conflicts => :file, :short => :m
-        opt :file,    "read the data from the named file. One message per line", :type => :string, :conflicts => :message, :short => :f
-        opt :number,  "the number of times to send the message", :type => :integer, :default => 1, :short => :n, :conflicts => :file
+        opt :message, "the message, as json", :type => :string, :short => :m
+        opt :file,    "read messages from the named file", :type => :string, :short => :f
+        opt :number,  "the number of times to send the message", :type => :integer, :default => 1, :short => :n
+        opt :reply,   "set a reply listener.", :short => :r
+        opt :timeout, "timeout when waiting for a reply", :type => :integer, :depends => :reply, :default => Smith.config.agency.timeout
         opt :dynamic, "send message to a dynamic queue", :type => :boolean, :default => false, :short => :d
+
+        conflicts :reply, :number, :file
+        conflicts :message, :file
+      end
+
+      class FileReader
+        def initialize(file)
+          @file = (file.is_a?(IO)) ? file : File.open(file)
+        end
+
+        def each(on_work, on_completed)
+          on_done = proc do |message|
+            line = @file.readline rescue nil
+            if line
+              class << on_done; alias :next :call; end
+              on_work.call(line, on_done)
+            else
+              on_completed.call
+            end
+          end
+
+          EM.next_tick(&on_done)
+        end
       end
     end
   end

data/lib/smith/commands/smithctl/rm.rb

@@ -5,24 +5,23 @@ module Smith
       def execute
         case target.size
         when 0
-          responder.value("No queue specified. Please specify a queue.")
+          responder.succeed("No queue specified. Please specify a queue.")
         else
-          Smith.on_error do |ch,channel_close|
+          @on_error = proc do |ch,channel_close|
             case channel_close.reply_code
             when 404
-              responder.value("No such queue: #{extract_queue(channel_close.reply_text)}")
+              responder.succeed("No such queue: [#{channel_close.reply_code}]: #{channel_close.reply_text}")
             when 406
-              responder.value("Queue not empty: #{extract_queue(channel_close.reply_text)}. Use -f to force remove")
+              responder.succeed("Queue not empty: [#{channel_close.reply_code}]: #{channel_close.reply_text}.")
             else
-              responder.value("Unknown error: #{channel_close.reply_text}")
+              responder.succeed("Unknown error: [#{channel_close.reply_code}]: #{channel_close.reply_text}")
             end
           end
 
           target.each do |queue_name|
-            Smith.channel.queue("smith.#{queue_name}", :passive => true) do |queue|
-              queue_options = (options[:force]) ? {} : {:if_unused => true, :if_empty => true}
-              queue.delete(queue_options) do |delete_ok|
-                responder.value((options[:verbose]) ? delete_ok.message_count.to_s : nil)
+            delete_queue(queue_name) do |delete_ok|
+              delete_exchange(queue_name) do |delete_ok|
+                responder.succeed((options[:verbose]) ? delete_ok.message_count.to_s : nil)
               end
             end
           end
@@ -38,6 +37,30 @@ module Smith
         opt    :verbose, "print the number of messages deleted", :short => :v
       end
 
+      def delete_exchange(exchange_name, &blk)
+        AMQP::Channel.new(Smith.connection) do |channel,ok|
+          channel.on_error(&@on_error)
+          channel.direct("smith.#{exchange_name}", :passive => true) do |exchange|
+            exchange_options = (options[:force]) ? {} : {:if_unused => true}
+            exchange.delete(exchange_options) do |delete_ok|
+              blk.call(delete_ok)
+            end
+          end
+        end
+      end
+
+      def delete_queue(queue_name, &blk)
+        AMQP::Channel.new(Smith.connection) do |channel,ok|
+          channel.on_error(&@on_error)
+          channel.queue("smith.#{queue_name}", :passive => true) do |queue|
+            queue_options = (options[:force]) ? {} : {:if_unused => true, :if_empty => true}
+            queue.delete(queue_options) do |delete_ok|
+              blk.call(delete_ok)
+            end
+          end
+        end
+      end
+
       def extract_queue(message)
         match = /.*?'(.*?)'.*$/.match(message) #[1]
         if match && match[1]

data/lib/smith/commands/smithctl/subscribe.rb

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+module Smith
+  module Commands
+    class Subscribe < CommandBase
+      def execute
+        Messaging::Receiver.new(target.first, amqp_opts) do |receiver|
+          receiver.subscribe do |payload, r|
+            pp payload
+          end
+        end
+      end
+
+      private
+
+      def amqp_opts
+        {}.tap do |amqp|
+          [:durable, :auto_delete, :header].each do |k|
+            if k == :header && !options[k].nil?
+              amqp[k] = eval(options[k])
+            else
+              amqp[k] = options[k]
+            end
+          end
+        end
+      end
+
+      def options_spec
+        banner "Subcribe to the named queue and print and received messages to stdout."
+
+        opt    :durable,     "amqp durable option", :default => false
+        opt    :auto_delete, "amqp auto-delete option", :default => false
+        opt    :header,      "amqp headers as json", :type => :string
+      end
+    end
+  end
+end

data/lib/smith/commands/smithctl/top.rb

@@ -9,7 +9,7 @@ module Smith
         Curses.init_screen()
         win = Curses::Window.new(Curses.lines, Curses.cols, 0, 0)
 
-        Messaging::Receiver.new('agent.stats', :durable => false, :auto_delete => false).ready do |receiver|
+        Messaging::Receiver.new(QueueDefinitions::Agent_stats) do |receiver|
           receiver.subscribe do |r|
             payload = r.payload
             win.setpos(0,0)

data/lib/smith/exceptions.rb

@@ -7,6 +7,8 @@ module Smith
   end
 
   module Messaging
+    class ACLTimeoutError < RuntimeError; end
+
     class IncompletePayload < RuntimeError; end
     class IncorrectPayloadType < RuntimeError; end
   end

data/lib/smith/messaging/acl/agency_command.proto

@@ -3,3 +3,7 @@ message AgencyCommand {
   required string command = 1;
   repeated string args = 2;
 }
+
+message AgencyCommandResponse {
+  optional string response = 1;
+}

data/lib/smith/messaging/acl/default.rb

@@ -1,4 +1,7 @@
 # -*- encoding: utf-8 -*-
+
+require 'yajl'
+
 module Smith
   module ACL
 
@@ -29,11 +32,15 @@ module Smith
         @message.to_s
       end
 
+      def to_hash
+        @message && @message.to_hash
+      end
+
       def inspect
         "<#{self.class.to_s}> -> #{(self.respond_to?(:to_hash)) ? self.to_hash : self.to_s}"
       end
 
-      def as_json
+      def to_json
         Yajl.dump(@message)
       end
 

data/lib/smith/messaging/amqp_options.rb

@@ -4,7 +4,7 @@ module Smith
     class AmqpOptions
       include Logger
 
-      attr_accessor :queue_name
+      attr_accessor :routing_key
 
       def initialize(options={})
         @options = options
@@ -24,7 +24,7 @@ module Smith
       end
 
       def publish(*extra_opts)
-        merge(Smith.config.amqp.publish.to_hash, {:routing_key => queue_name}, extra_opts)
+        merge(Smith.config.amqp.publish.to_hash, {:routing_key => routing_key, :persistent => true}, extra_opts)
       end
 
       def subscribe(*extra_opts)

data/lib/smith/messaging/message_counter.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+module Smith
+  module Messaging
+    class MessageCounter
+
+      def initialize(queue_name)
+        @message_counts = Hash.new(0)
+        @queue_name = queue_name
+      end
+
+      # Return the total number of messages sent or received for the named queue.
+      def counter
+        @message_counts[@queue_name]
+      end
+
+      def increment_counter(value=1)
+        @message_counts[@queue_name] += value
+      end
+    end
+  end
+end

data/lib/smith/messaging/payload.rb

@@ -1,101 +1,99 @@
 # -*- encoding: utf-8 -*-
 module Smith
-  module ACL
 
+  module ACL
     module ACLInstanceMethods
       def inspect
         "<#{self.class.to_s}> -> #{self.to_hash}"
       end
 
-      def as_json
+      def to_json
         Yajl.dump(self.to_hash)
       end
     end
 
-    module ClassMethods
-      def content_class(e)
-        @@acl_classes ||= {:default => Default}
+    class Factory
+      include Logger
 
-        e = e.to_sym
+      @@acl_classes = {:default => Default}
 
-        if @@acl_classes.include?(e)
-          @@acl_classes[e]
-        else
-          class_name = Extlib::Inflection.camelize(e)
-          if ACL.constants.include?(class_name)
-            logger.error { "Shouldn't get here." }
+      class << self
+        def create(type, content=nil, &blk)
+          type = type.to_s
+
+          unless @@acl_classes.include?(type)
+            logger.debug { "Loading ACL: #{type}" }
+            # decorate the ACL class
+            @@acl_classes[type] = clazz(type).send(:include, ACLInstanceMethods)
+            @@acl_classes[type].send(:define_method, :_type) { type }
+          end
+
+          if blk
+            if content.nil?
+              @@acl_classes[type].new.tap { |m| blk.call(m) }
+            else
+              raise ArgumentError, "You cannot give a content hash and a block."
+            end
           else
-            logger.debug { "#{class_name} Loaded from #{e}.pb.rb" }
-            ACL.const_get(class_name).tap do |clazz|
-              # Override the inspect method
-              @@acl_classes[e] = clazz.send(:include, ACLInstanceMethods)
+            if content.respond_to?(:serialize_to_string)
+              content
+            elsif content.nil?
+              @@acl_classes[type].new
+            else
+              @@acl_classes[type].new(content)
             end
           end
         end
+
+        def clazz(type)
+          type.split(/::/).inject(ACL) do |a,m|
+            a.const_get(Extlib::Inflection.camelize(m))
+          end
+        end
       end
     end
 
     class Payload
       include Logger
 
-      include ClassMethods
-      extend ClassMethods
-
       # content can be an existing ACL class.
-      def initialize(type=:default, opts={})
-        if opts[:from]
-          @type = opts[:from].class.to_s.split(/::/).last.snake_case
-          @content = opts[:from]
-        else
-          @type = type
-          @clazz = content_class(type)
-        end
-      end
-
-      # Add content to the content or get the content from a payload
-      def content(*content, &block)
-        if content.empty?
-          if block.nil?
-            return @content
-          else
-            @content = @clazz.new
-            block.call(@content)
-          end
+      def initialize(acl, opts={})
+        if acl.respond_to?(:serialize_to_string)
+          @acl = acl
         else
-          @content = @clazz.new(content.first)
+          raise ArgumentError, "ACL does not have a serialize_to_string method."
         end
-        self
       end
 
       # The type of content.
-      def type
-        @type.to_s
+      def _type
+        @acl._type
       end
 
       # Returns a hash of the payload.
       def to_hash
-        @content.to_hash
+        @acl.to_hash
       end
 
       # Encode the content, returning the encoded data.
       def encode
-        @content.serialize_to_string
+        @acl.serialize_to_string
       end
 
       # Returns true if the payload has all its required fields set.
       def initialized?
-        raise RuntimeError, "You probably forgot to call #content or give the :from option when instantiating the object." if @content.nil?
-        @content.initialized?
+        raise RuntimeError, "You probably forgot to call #content or give the :from option when instantiating the object." if @acl.nil?
+        @acl.initialized?
       end
 
       # Convert the payload to a pretty string.
       def to_s
-        @content.inspect
+        @acl.inspect
       end
 
       # Decode the content using the specified decoder.
-      def self.decode(payload, decoder=:default)
-        content_class(decoder).new.parse_from_string(payload)
+      def self.decode(payload, type=:default)
+        Factory.create(type).parse_from_string(payload)
       end
     end
   end