smith 0.5.12 → 0.5.13.1

data/lib/smith/agent_process.rb

@@ -65,6 +65,13 @@ module Smith
       end
     end
 
+    def add_callback(state, &blk)
+      AgentProcess.state_machine do
+        puts "changing callback"
+        after_transition :on => state, :do => blk
+      end
+    end
+
     # Check to see if the agent is alive.
     def alive?
       if self.pid
@@ -128,18 +135,20 @@ module Smith
     end
 
     def self.stop(agent_process)
-      Messaging::Sender.new(agent_process.control_queue_name, :durable => false, :auto_delete => true).ready do |sender|
-        callback = proc {|sender| sender.publish(ACL::Payload.new(:agent_command).content(:command => 'stop')) }
-        errback = proc do
-          logger.warn { "Agent is not listening. Setting state to dead." }
-          agent_process.no_process_running
+      Messaging::Sender.new(agent_process.control_queue_name, :durable => false, :auto_delete => true) do |sender|
+        sender.consumer_count do |count|
+          if count > 0
+            sender.publish(ACL::Factory.create(:agent_command, :command => 'stop'))
+          else
+            logger.warn { "Agent is not listening. Setting state to dead." }
+            agent_process.no_process_running
+          end
         end
-
-        sender.consumers?(callback, errback)
       end
     end
 
     def self.acknowledge_stop(agent_process)
+      pp :stopped
     end
 
     def self.kill(agent_process)
@@ -172,10 +181,8 @@ module Smith
 
   AgentProcess.state_machine do
     after_transition :on => :start, :do => AgentProcessObserver.method(:start)
-    after_transition :on => :acknowledge_start, :do => AgentProcessObserver.method(:acknowledge_start)
     after_transition :on => :stop, :do => AgentProcessObserver.method(:stop)
     after_transition :on => :kill, :do => AgentProcessObserver.method(:kill)
-    after_transition :on => :acknowledge_stop, :do => AgentProcessObserver.method(:acknowledge_stop)
     after_transition :on => :not_responding, :do => AgentProcessObserver.method(:reap_agent)
   end
 end

data/lib/smith/amqp_errors.rb

@@ -0,0 +1,53 @@
+# -*- encoding: utf-8 -*-
+
+module Smith
+  module Messaging
+    module AmqpErrors
+
+      private
+
+      def error_message(code, text, &blk)
+        details = error_lookup(code)
+        message = "#{details[:error_class]} exception: #{code} (#{details[:name]}). #{details[:description]}"
+
+        case code
+        when 404
+          diagnosis = "looks like the queue has been deleted."
+        when 406
+          case text
+          when /.*(unknown delivery tag [0-9]+).*/
+            diagnosis = "#{$1} - you've probably already acknowledged the message."
+          end
+        else
+        end
+        blk.call(message, diagnosis)
+      end
+
+      def error_lookup(code)
+        errors[code]
+      end
+
+      def errors
+        @errors ||= {
+          311 => {:name => "content-too-large", :error_class => "Channel", :description => "The client attempted to transfer content larger than the server could accept at the present time. The client may retry at a later time."},
+          313 => {:name => "no-consumers", :error_class => "Channel", :description => "When the exchange cannot deliver to a consumer when the immediate flag is set. As a result of pending data on the queue or the absence of any consumers of the queue."},
+          320 => {:name => "connection-forced", :error_class => "Connection", :description => "An operator intervened to close the Connection for some reason. The client may retry at some later date."},
+          402 => {:name => "invalid-path", :error_class => "Connection", :description => "The client tried to work with an unknown virtual host."},
+          403 => {:name => "access-refused", :error_class => "Channel", :description => "The client attempted to work with a server entity to which it has no access due to security settings."},
+          404 => {:name => "not-found", :error_class => "Channel", :description => "The client attempted to work with a server entity that does not exist."},
+          405 => {:name => "resource-locked", :error_class => "Channel", :description => "The client attempted to work with a server entity to which it has no access because another client is working with it."},
+          406 => {:name => "precondition-failed", :error_class => "Channel", :description => "The client requested a method that was not allowed because some precondition failed."},
+          501 => {:name => "frame-error", :error_class => "Connection", :description => "The sender sent a malformed frame that the recipient could not decode. This strongly implies a programming error in the sending peer."},
+          502 => {:name => "syntax-error", :error_class => "Connection", :description => "The sender sent a frame that contained illegal values for one or more fields. This strongly implies a programming error in the sending peer."},
+          503 => {:name => "command-invalid", :error_class => "Connection", :description => "The client sent an invalid sequence of frames, attempting to perform an operation that was considered invalid by the server. This usually implies a programming error in the client."},
+          504 => {:name => "channel-error", :error_class => "Connection", :description => "The client attempted to work with a Channel that had not been correctly opened. This most likely indicates a fault in the client layer."},
+          505 => {:name => "unexpected-frame", :error_class => "Connection", :description => "The peer sent a frame that was not expected, usually in the context of a content header and body. This strongly indicates a fault in the peer's content processing."},
+          506 => {:name => "resource-error", :error_class => "Connection", :description => "The server could not complete the method because it lacked sufficient resources. This may be due to the client creating too many of some type of entity."},
+          530 => {:name => "not-allowed", :error_class => "Connection", :description => "The client tried to work with some entity in a manner that is prohibited by the server, due to security settings or by some other criteria."},
+          540 => {:name => "not-implemented", :error_class => "Connection", :description => "The client tried to use functionality that is not implemented in the server."},
+          541 => {:name => "internal-error", :error_class => "Connection", :description => "The server could not complete the method because of an internal error. The server may require intervention by an operator in order to resume normal operations."}
+        }
+      end
+    end
+    end
+  end

data/lib/smith/application/agency.rb

@@ -15,39 +15,42 @@ module Smith
     end
 
     def setup_queues
-      Messaging::Receiver.new('agency.control', :auto_delete => false, :durable => false, :strict => true).ready do |receiver|
-        receiver.subscribe do |r|
-          r.reply do |responder|
-            # Add a logger proc to the responder chain.
-            responder.callback { |ret| logger.debug { ret } if ret && !ret.empty? }
-
-            begin
-              Command.run(r.payload.command, r.payload.args, :agency => self,  :agents => @agent_processes, :responder => responder)
-            rescue Command::UnknownCommandError => e
-              responder.value("Unknown command: #{r.payload.command}")
+      Messaging::Receiver.new(QueueDefinitions::Agency_control) do |receiver|
+        receiver.subscribe do |payload, responder|
+
+          completion = EM::Completion.new.tap do |c|
+            c.completion do |value|
+              pp value
+              responder.reply(Smith::ACL::Factory.create(:agency_command_response, :response => value))
             end
           end
+
+          begin
+            Command.run(payload.command, payload.args, :agency => self,  :agents => @agent_processes, :responder => completion)
+          rescue Command::UnknownCommandError => e
+            responder.reply("Unknown command: #{payload.command}")
+          end
         end
       end
 
-      Messaging::Receiver.new('agent.lifecycle', :auto_delete => false, :durable => false).ready do |receiver|
-        receiver.subscribe do |r|
-          case r.payload.state
+      Messaging::Receiver.new(QueueDefinitions::Agent_lifecycle) do |receiver|
+        receiver.subscribe do |payload, r|
+          case payload.state
           when 'dead'
-            dead(r.payload)
+            dead(payload)
           when 'acknowledge_start'
-            acknowledge_start(r.payload)
+            acknowledge_start(payload)
           when 'acknowledge_stop'
-            acknowledge_stop(r.payload)
+            acknowledge_stop(payload)
           else
-            logger.warn { "Unknown command received on agent.lifecycle queue: #{r.payload.state}" }
+            logger.warn { "Unknown command received on #{QueueDefinitions::Agent_lifecycle.name} queue: #{payload.state}" }
           end
         end
       end
 
-      Messaging::Receiver.new('agent.keepalive', :auto_delete => false, :durable => false).ready do |receiver|
-        receiver.subscribe do |r|
-          keep_alive(r.payload)
+      Messaging::Receiver.new(QueueDefinitions::Agent_keepalive) do |receiver|
+        receiver.subscribe do |payload, r|
+          keep_alive(payload)
         end
       end
     end

data/lib/smith/bootstrap.rb

@@ -6,6 +6,7 @@
 $: << File.dirname(__FILE__) + '/..'
 
 require 'smith'
+require 'smith/agent'
 
 module Smith
   class AgentBootstrap
@@ -44,7 +45,6 @@ module Smith
     def start!
       write_pid_file
       @agent.run
-      @agent.started
     end
 
     # Exceptional shutdown of the agent. Note. Whenever this is
@@ -84,8 +84,8 @@ module Smith
 
     def send_dead_message
       logger.debug { "Sending dead message to agency: #{@agent_name}" }
-      Messaging::Sender.new('agent.lifecycle', :auto_delete => false, :durable => false).ready do |sender|
-        sender.publish(ACL::Payload.new(:agent_lifecycle).content(:state => 'dead', :name => @agent_name))
+      Messaging::Sender.new(QueueDefinitions::Agent_lifecycle) do |sender|
+        sender.publish(ACL::Factory.create(:agent_lifecycle, :state => 'dead', :name => @agent_name))
       end
     end
 

data/lib/smith/command.rb

@@ -38,9 +38,9 @@ module Smith
         clazz.execute
 
       rescue Trollop::CommandlineError => e
-        vars[:responder].value(clazz.format_help(:prefix => "Error: #{e.message}.\n"))
+        vars[:responder].succeed(clazz.format_help(:prefix => "Error: #{e.message}.\n"))
       rescue Trollop::HelpNeeded
-        vars[:responder].value(clazz.format_help)
+        vars[:responder].succeed(clazz.format_help)
       end
     end
 

data/lib/smith/command_base.rb

@@ -47,6 +47,10 @@ module Smith
       @parser.conflicts(*syms)
     end
 
+    def depends(*syms)
+      @parser.depends(*syms)
+    end
+
     def options_spec
       banner "You should really set a proper banner notice for this command."
     end

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

@@ -3,26 +3,26 @@ module Smith
   module Commands
     class Agents < CommandBase
       def execute
-        responder.value do
-          # FIXME make sure that if the path doesn't exist don't blow up.
-          agent_paths = Smith.agent_paths.inject([]) do |path_acc,path|
-            path_acc.tap do |a|
-              if path.exist?
-                a << path.each_child.inject([]) do |agent_acc,p|
-                  agent_acc.tap do |b|
-                    b << Extlib::Inflection.camelize(p.basename('.rb')) if p.file? && p.basename('.rb').to_s.end_with?("agent")
-                  end
-                end.flatten
-              else
-                error_message = "Agent path doesn't exist: #{path}"
-                responder.value(error_message)
-                []
-              end
+        responder.succeed(_agents)
+      end
+
+      def _agents
+        # FIXME make sure that if the path doesn't exist don't blow up.
+        separator = (options[:one_column]) ? "\n" : " "
+
+        Smith.agent_paths.inject([]) do |path_acc,path|
+          path_acc.tap do |a|
+            if path.exist?
+              a << path.each_child.inject([]) do |agent_acc,p|
+                agent_acc.tap do |b|
+                  b << Extlib::Inflection.camelize(p.basename('.rb')) if p.file? && p.basename('.rb').to_s.end_with?("agent")
+                end
+              end.flatten
+            else
+              return "Agent path doesn't exist: #{path}"
             end
-          end.flatten
-          separator = (options[:one_column]) ? "\n" : " "
-          (agent_paths.empty?) ? "" : agent_paths.sort.join(separator)
-        end
+          end
+        end.flatten.sort.join(separator)
       end
 
       private

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

@@ -3,10 +3,14 @@ module Smith
   module Commands
     class Kill < CommandBase
       def execute
-        target.each do |agent_name|
+        work = ->(agent_name, iter) do
           agents[agent_name].kill
+          iter.next
         end
-        responder.value
+
+        done = -> { responder.succeed('') }
+
+        EM::Iterator.new(target).each(work, done)
       end
 
       private

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

@@ -3,10 +3,8 @@ module Smith
   module Commands
     class List < CommandBase
       def execute
-        responder.value do
-          a = (options[:all]) ? agents : agents.state(:running)
-          (a.empty?) ? nil : format(a, options[:long])
-        end
+        selected_agents = (options[:all]) ? agents : agents.state(:running)
+        responder.succeed((selected_agents.empty?) ? '' : format(selected_agents, options[:long]))
       end
 
       private

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

@@ -3,44 +3,43 @@ module Smith
   module Commands
     class Logger < CommandBase
       def execute
-        responder.value do
-          if options[:level].nil?
-            "No log level. You must specify a log level and a target"
+        responder.succeed(_logger)
+      end
+
+      def _logger(&blk)
+        if options[:level].nil?
+          "No log level. You must specify a log level and a target"
+        else
+          case target.first
+          when 'all'
+            agents.state(:running).each do |agent|
+              send_agent_control_message(agent, :command => 'log_level', :options => options[:level])
+            end
+          when 'agency'
+            begin
+              logger.info { "Setting agency log level to: #{options[:level]}" }
+              log_level(options[:level])
+            rescue ArgumentError
+              logger.error { "Incorrect log level: #{options[:level]}" }
+            end
+          when nil
+            "No target. You must specify one of the following: 'agency', 'all' or a list of agents"
           else
-            case target.first
-            when 'all'
-              agents.state(:running).each do |agent|
-                send_agent_control_message(agent, :command => 'log_level', :options => options[:level])
-              end
-              nil
-            when 'agency'
-              begin
-                logger.info { "Setting agency log level to: #{options[:level]}" }
-                log_level(options[:level])
-                nil
-              rescue ArgumentError
-                logger.error { "Incorrect log level: #{options[:level]}" }
-                nil
-              end
-            when nil
-              "No target. You must specify one of the following: 'agency', 'all' or a list of agents"
-            else
-              target.each do |agent|
-                if agents[agent].running?
-                  send_agent_control_message(agents[agent], :command => 'log_level', :options => [options[:level]])
-                end
+            target.each do |agent|
+              if agents[agent].running?
+                send_agent_control_message(agents[agent], :command => 'log_level', :options => [options[:level]])
               end
-              nil
             end
           end
         end
+        ''
       end
 
       private
 
       def send_agent_control_message(agent, message)
-        Messaging::Sender.new(agent.control_queue_name, :durable => false, :auto_delete => true, :persistent => true,  :strict => true).ready do |sender|
-          sender.publish(ACL::Payload.new(:agent_command).content(message))
+        Messaging::Sender.new(agent.control_queue_name, :durable => false, :auto_delete => true, :persistent => true,  :strict => true) do |sender|
+          sender.publish(ACL::Factory.create(:agent_command, message))
         end
       end
 

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

@@ -3,11 +3,7 @@ module Smith
   module Commands
     class Metadata < CommandBase
       def execute
-        responder.value do
-          target.inject([]) do |acc,agent_name|
-            acc.tap { |a| a << ["#{agent_name}: #{agents[agent_name].metadata}"] }
-          end.join("\n")
-        end
+        responder.succeed(target.inject([]) { |acc,agent_name| acc.tap { |a| a << ["#{agent_name}: #{agents[agent_name].metadata}"] } }.join("\n"))
       end
 
       private

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

@@ -4,24 +4,26 @@ module Smith
   module Commands
     class ObjectCount < CommandBase
       def execute
-        responder.value do
-          target.each do |agent|
-            if agents[agent].running?
-              send_agent_control_message(agents[agent], :command => 'object_count', :options => [options[:threshold].to_s])
-            end
+        if target.size > 1
+          responder.succeed("You can only specify one agent at at time.")
+        else
+          object_count(target.first) do |objects|
+            responder.succeed(objects)
           end
-          nil
         end
       end
 
-      private
-
-      def send_agent_control_message(agent, message)
-        Messaging::Sender.new(agent.control_queue_name, :durable => false, :auto_delete => true, :persistent => true,  :strict => true).ready do |sender|
-          sender.publish(ACL::Payload.new(:agent_command).content(message))
+      def object_count(agent, &blk)
+        if agents[agent].running?
+          Messaging::Sender.new(agent.control_queue_name, :durable => false, :auto_delete => true, :persistent => true,  :strict => true) do |sender|
+            sender.on_reply(blk)
+            sender.publish(ACL::Payload.new(:agent_command, :command => 'object_count', :options => [options[:threshold].to_s]))
+          end
         end
       end
 
+      private
+
       def options_spec
         banner "Dump the ruby ObjectSpace stats. This is purely for debuging purposes only."
 

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

@@ -12,17 +12,26 @@ module Smith
       include Common
 
       def execute
-        Messaging::Sender.new('agency.control', :auto_delete => false, :durable => false, :strict => true).ready do |sender|
-          payload = ACL::Payload.new(:agency_command).content(:command => 'stop', :args => target)
-
-          sender.publish_and_receive(payload) do |r|
-            payload = ACL::Payload.new(:agency_command).content(:command => 'start', :args => target)
-            EM.add_timer(0.5) do
-              sender.publish_and_receive(payload) do |r|
-                responder.value
-              end
+        Messaging::Sender.new(QueueDefinitions::Agency_control) do |sender|
+          @sender = sender
+
+          # agent is a method and as such I cannot pass it into the block.
+          # This just assigns it to a local method making it all work.
+
+          lagents = agents
+          # lagents.each do |agent_name|
+          worker = ->(agent_name, iter) do
+            lagents[agent_name].stop
+            lagents[agent_name].add_callback(:acknowledge_stop) do
+              lagents.invalidate(agent_name)
+              lagents[agent_name].start
             end
+            iter.next
           end
+
+          done = -> { responder.succeed('') }
+
+          EM::Iterator.new(target).each(worker, done)
         end
       end