smith 0.5.12 → 0.5.13.1

data/lib/smith/commands/agency/start.rb

@@ -9,7 +9,12 @@ module Smith
       include Common
 
       def execute
+        start do |value|
+          responder.succeed(value)
+        end
+      end
 
+      def start(&blk)
         #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
         #!!!!!!!!!!!! See note about target at end of this file !!!!!!!!!!!!!!
         #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
@@ -20,41 +25,45 @@ module Smith
           begin
             agents_to_start = agent_group(options[:group])
             if agents_to_start.empty?
-              responder.value("There are no agents in group: #{options[:group]}")
-              return
+              blk.call("Agent group is empty. No agents started: #{options[:group]}")
+            else
+              start_agents(agents_to_start, &blk)
             end
           rescue RuntimeError => e
-            responder.value(e.message)
-            return
+            blk.call(e.message)
           end
         else
-          agents_to_start = target
+          start_agents(target, &blk)
         end
+      end
 
-        responder.value do
-          if agents_to_start.empty?
-            "Start what? No agent specified."
-          else
-            agents_to_start.map do |agent|
-              agents[agent].name = agent
-              if agents[agent].path
-                if options[:kill]
-                  agents[agent].kill
-                end
-                agents[agent].start
-                nil
-              else
-                "Unknown agent: #{agents[agent].name}".tap do |m|
-                  logger.error { m }
-                end
+      private
+
+      def start_agents(agents_to_start, &blk)
+        if agents_to_start.empty?
+          blk.call("Start what? No agent specified.")
+        else
+          worker = ->(agent_name, iter) do
+            agents[agent_name].name = agent_name
+            if agents[agent_name].path
+              if options[:kill]
+                agents[agent_name].kill
               end
-            end.compact.join("\n")
+              agents[agent_name].start
+              iter.return(agent_name)
+            else
+              iter.return("Unknown agent: #{agents[agent_name].name}")
+            end
+          end
+
+          done = ->(started_agents) do
+            blk.call(started_agents.compact.join("\n"))
           end
+
+          EM::Iterator.new(agents_to_start).map(worker, done)
         end
       end
 
-      private
-
       def options_spec
         banner "Start an agent/agents or group of agents."
 
@@ -70,6 +79,6 @@ end
 #
 # Target is a method and if you assign something to it strange things happen --
 # even if the code doesn't get run! I'm not strictly sure what's going on but I
-# think it's something to do with the a variable aliasing a method of the same
+# think it's something to do with variable aliasing a method of the same
 # name. So even though the code isn't being run it gets compiled and that
 # somehow aliases the method. This looks like a bug in yarv to me.

data/lib/smith/commands/agency/stop.rb

@@ -9,65 +9,82 @@ module Smith
       include Common
 
       def execute
+        if target.first == 'agency' || target.first == 'all'
+          send("stop_#{target.first}") { |ret| responder.succeed(ret) }
+        else
+          stop_agent { |ret| responder.succeed(ret) }
+        end
+      end
 
-        #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-        #!!!!!!!!!!!! See note about target at end of this file !!!!!!!!!!!!!!
-        #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+      private
 
-        case target.first
-        when 'agency'
-          running_agents = agents.state(:running)
-          if running_agents.empty?
-            logger.info { "Agency shutting down." }
+      def stop_agency(&blk)
+        running_agents = agents.state(:running)
+        if running_agents.empty?
+          logger.info { "Agency shutting down." }
+           blk.call('')
+          Smith.stop
+        else
+          if options[:force]
+            blk.call('')
             Smith.stop
-            responder.value
           else
             logger.warn { "Agents are still running: #{running_agents.map(&:name).join(", ")}." }
             logger.info { "Agency not shutting down. Use force_stop if you really want to shut it down." }
-            responder.value("Not shutting down, agents are still running: #{running_agents.map(&:name).join(", ")}.")
+            blk.call("Not shutting down, agents are still running: #{running_agents.map(&:name).join(", ")}.")
           end
-        when 'all'
-          agents.state(:running).each do |agent|
-            agent.stop
-          end
-          responder.value
-        else
-          # Sort out any groups. If the group option is set it will override
-          # any other specified agents.
-          if options[:group]
-            begin
-              agents_to_stop = agent_group(options[:group])
-              if agents_to_stop.empty?
-                responder.value("There are no agents in group: #{options[:group]}")
-                return
-              end
-            rescue RuntimeError => e
-              responder.value(e)
-              return
+        end
+      end
+
+      def stop_all(&blk)
+        agents.state(:running).each do |agent|
+          agent.stop
+        end
+        blk.call('')
+      end
+
+      def stop_agent(&blk)
+
+        #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        #!!!!!!!!!!!! See note about target at end of this file !!!!!!!!!!!!!!
+        #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+        # Sort out any groups. If the group option is set it will override
+        # any other specified agents.
+        if options[:group]
+          begin
+            agents_to_stop = agent_group(options[:group])
+            if agents_to_stop.empty?
+              blk.call("There are no agents in group: #{options[:group]}")
             end
-          else
-            agents_to_stop = target
+          rescue RuntimeError => e
+            return blk.call(e.message)
           end
+        else
+          agents_to_stop = target
+        end
 
-          ret = agents_to_stop.inject([]) do |acc,agent_name|
-            acc << if agents[agent_name].running?
-                     agents[agent_name].stop
-                     nil
-                   else
-                     logger.warn { "Agent not running: #{agent_name}" }
-                     agent_name
-                   end
-          end
-          responder.value((ret.compact.empty?) ? nil : "Agent(s) not running: #{ret.compact.join(", ")}")
+        ret = agents_to_stop.inject([]) do |acc,agent_name|
+          acc << stop_if_running(agents[agent_name])
         end
+        blk.call((ret.compact.empty?) ? '' : "Agent(s) not running: #{ret.compact.join(", ")}")
       end
 
-      private
+      def stop_if_running(agent)
+        if agent.running?
+          agent.stop
+          nil
+        else
+          logger.warn { "Agent not running: #{agent.name}" }
+          agent.name
+        end
+      end
 
       def options_spec
         banner "Stop an agent/agents."
 
         opt    :group, "Stop everything in the specified group", :type => :string, :short => :g
+        opt    :force, "If stopping the agency and there are agents running stop anyway"
       end
     end
   end

data/lib/smith/commands/agency/version.rb

@@ -3,19 +3,19 @@ module Smith
   module Commands
     class Version < CommandBase
       def execute
-        # FIXME Puts some error handling for when the agency isn't running in a git repo.
+        version do |v|
+          responder.succeed(v)
+        end
+      end
+
+      def version(&blk)
         if options[:git]
-          EM.system('git describe') do |output,status|
-            responder.value do
-              if status.exitstatus == 0
-                output.strip
-              else
-                'The agency is not running in a git repo.'
-              end
-            end
+          # EM.system doesn't do any shell expansion so do it ourselves.
+          EM.system("sh -c 'git describe 2> /dev/null'") do |output,status|
+            blk.call((status.exitstatus == 0) ? output.strip : 'The agency is not running in a git repo.')
           end
         else
-          responder.value(Smith::VERSION)
+          blk.call(Smith::VERSION)
         end
       end
 

data/lib/smith/commands/common.rb

@@ -3,15 +3,18 @@ module Smith
   module Commands
     module Common
       def agent_group(group)
-        Smith.agent_paths.map do |path|
+        agents = Smith.agent_paths.map do |path|
           group_dir = path.join(group)
           if group_dir.exist? && group_dir.directory?
             agents = Pathname.glob("#{path.join(group)}/*_agent.rb")
-            return agents.map {|a| Extlib::Inflection.camelize(a.basename(".rb").to_s)}
+            agents.map {|a| Extlib::Inflection.camelize(a.basename(".rb").to_s)}
           else
-            raise RuntimeError, "Group does not exist: #{group}"
+            nil
           end
-        end
+        end.uniq
+
+        raise RuntimeError, "Group does not exist: #{group}" if agents == [nil]
+        agents.compact.flatten
       end
     end
   end

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

@@ -6,52 +6,60 @@ module Smith
   module Commands
     class Acl < CommandBase
       def execute
-        responder.value do
-          if options[:show_given]
-            if target.empty?
-              "You must supply an ACL file name."
-            else
-              target.map do |acl|
-                acls = Smith.acl_path.inject([]) do |a,path|
-                  a.tap do |acc|
-                    acl_file = path.join("#{acl.snake_case}.proto")
-                    if acl_file.exist?
-                      acc << acl_file
-                    end
-                  end
-                end
+        responder.succeed(_acl)
+      end
 
-                case acls.length
-                when 0
-                  "ACL file does not exist."
-                when 1
-                  if target.length == 1
-                    "\n#{indent_acl(acls.first.read)}\n"
-                  else
-                    "\n#{acl} ->\n#{indent_acl(acls.first.read)}"
-                  end
+      def _acl
+        if options[:show]
+          if target.empty?
+            "You must supply an ACL file name."
+          else
+            target.map do |acl|
+              if options[:source_given]
+                acls = find_acl(Smith.acl_cache_path, acl, 'pb.rb')
+              else
+                acls = find_acl(Smith.acl_path, acl, 'proto')
+              end
+
+              case acls.length
+              when 0
+                "ACL file does not exist."
+              when 1
+                if target.length == 1
+                  "\n#{indent_acl(acls.first.read)}\n"
                 else
-                  "There are multiple ACLs with the name: #{target}"
+                  "\n#{acl} ->\n#{indent_acl(acls.first.read)}"
                 end
-              end.join("\n")
-            end
-          elsif options[:clean_given]
-            Pathname.glob(Smith.acl_cache_path.join("*.pb.rb")).each {|p| p.unlink}
-            ""
-          elsif options[:compile_given]
-            Pathname.glob(Smith.compile_acls)
-            ""
-          else
-            join_string = (options[:long]) ? "\n" : " "
-            Pathname.glob(Smith.acl_path.map {|p| "#{p}#{File::SEPARATOR}*"}).map do |p|
-              p.basename(".proto")
-            end.sort.join(join_string)
+              else
+                "There are multiple ACLs with the name: #{target}"
+              end
+            end.join("\n")
           end
+        elsif options[:clean_given]
+          Pathname.glob(Smith.acl_cache_path.join("*.pb.rb")).each {|p| p.unlink}
+          ""
+        elsif options[:compile_given]
+          Pathname.glob(Smith.compile_acls)
+          ""
+        else
+          join_string = (options[:long]) ? "\n" : " "
+          Pathname.glob(Smith.acl_path.map {|p| "#{p}#{File::SEPARATOR}*"}).map do |p|
+            p.basename(".proto")
+          end.sort.join(join_string)
         end
       end
 
       private
 
+      def find_acl(path, acl, ext)
+        [path].flatten.inject([]) do |a,path|
+          a.tap do |acc|
+            acl_file = path.join("#{acl.snake_case}.#{ext}")
+            acc << acl_file if acl_file.exist?
+          end
+        end
+      end
+
       def indent_acl(acl)
         acl.split("\n").map { |l| l.sub(/^/, "  ") }.join("\n")
       end
@@ -61,6 +69,7 @@ module Smith
 
         opt    :long,     "format the listing", :short => :l
         opt    :show,     "show the contents of the acl file", :short => :s
+        opt    :source,   "show the contents of the generated acl file", :depends => :show
         opt    :clean,    "remove all compiled acls", :short => :none
         opt    :compile,  "compile all acls", :short => :none
       end

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

@@ -4,7 +4,7 @@ module Smith
     class Commands < CommandBase
       def execute
         commands = (target.empty?) ? Command.commands : target
-        responder.value(format(commands))
+        responder.succeed(format(commands))
       end
 
       def format(commands)

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

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+module Smith
+  module Commands
+    class Firehose < CommandBase
+      def execute
+        queue_name = target.first
+        AMQP::Channel.new(Smith.connection) do |channel,ok|
+          channel.topic('amq.rabbitmq.trace', :durable => true) do |exchange|
+            channel.queue('smith.firehose', :durable => true) do |queue|
+              queue.bind(exchange, :routing_key => "publish.#{Smith.config.smith.namespace}.#{queue_name}").subscribe do |m,p|
+                message = ACL::Payload.decode(p, m.headers['properties']['type'])
+                puts (options[:json_given]) ? message.to_json : message.inspect
+              end
+            end
+          end
+        end
+      end
+
+      def options_spec
+        b = ["Listens to the rabbitmq firehose for the named queue and prints decoded message to stdout.",
+             "  Be warned it can produce vast amounts of outpu.\n",
+             "  You _must_ run 'rabbitmqctl trace_on' for this to work."]
+        banner b.join("\n")
+
+        opt    :json ,  "return the JSON representation of the message", :short => :j
+      end
+    end
+  end
+end

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

@@ -1,60 +1,67 @@
 # -*- encoding: utf-8 -*-
 require 'yajl'
 
+require 'smith/messaging/queue'
+
 module Smith
   module Commands
     class Pop < CommandBase
       def execute
+        pop
+      end
+
+      def pop
         case target.size
         when 0
-          responder.value("No queue specified. Please specify a queue.")
+          "No queue specified. Please specify a queue."
         when 1
 
           queue = target.first
 
-          # What to do if there is a channel error.
-          Smith.on_error do |ch,channel_close|
-            case channel_close.reply_code
-            when 404
-              responder.value("Queue does not exist: #{queue}")
-            else
-              responder.value("Unknown error: #{channel_close.reply_text}")
-            end
-          end
+          Messaging::Queue.number_of_messages(queue) do |queue_length|
 
-          Messaging::Receiver.new(queue, :auto_ack => false, :passive => true).ready do |receiver|
-            callback = proc do
-              work = proc do |acc,n,iter|
-                receiver.pop do |r|
-                  if options[:remove]
-                    r.ack
-                  else
-                    r.reject(:requeue => true)
-                  end
+            # Number of messages on the queue.
+            number_to_remove = (options[:number] > queue_length) ? queue_length : options[:number]
+
+            Messaging::Receiver.new(queue, :auto_ack => false, :prefetch => number_to_remove, :passive => true) do |receiver|
 
-                  acc[:result] << print_message(r.payload) if options[:print]
-                  acc[:count] += 1
+              receiver.on_error do |ch,channel_close|
+                case channel_close.reply_code
+                when 404
+                  responder.succeed("Queue does not exist: #{queue}")
+                else
+                  responder.succeed("Unknown error: #{channel_close.reply_text}")
+                end
+              end
 
+              worker = proc do |acc, n, iter|
+                receiver.pop do |payload,r|
+                  if payload
+                    acc[:result] << print_message(payload) if options[:print]
+                    acc[:count] += 1
+
+                    if n == number_to_remove - 1
+                      if options[:remove]
+                        r.ack(true)
+                      else
+                        r.reject(:requeue => true)
+                      end
+                    end
+                  end
                   iter.return(acc)
                 end
               end
 
               finished = proc do |acc|
-                responder.value do
-                  logger.debug { "Removing #{acc[:count]} message from #{receiver.queue_name}" }
-                  acc[:result].join("\n")
-                end
+                logger.debug { "Removing #{acc[:count]} message from #{receiver.queue_name}" }
+                responder.succeed(acc[:result].join("\n"))
               end
 
-              EM::Iterator.new(0..options[:number] - 1).inject({:count => 0, :result => []}, work, finished)
+              EM::Iterator.new(0...number_to_remove).inject({:count => 0, :result => [], :ack => nil}, worker, finished)
             end
-
-            errback = proc {responder.value(nil)}
-
-            receiver.messages?(callback, errback)
           end
         else
-          responder.value("You can only specify one queue at a time")
+          "You can only specify one queue at a time"
         end
       end
 
@@ -62,7 +69,7 @@ module Smith
 
       def print_message(message)
         if options[:json]
-          message.as_json
+          message.to_json
         else
           message.inspect
         end