smith 0.5.12 → 0.5.13.1

data/bin/smithctl

@@ -10,10 +10,11 @@ $:.unshift(File.dirname(__FILE__) + '/../lib')
 
 require 'smith'
 
+include Smith::Logger
+
 module Smith
   class SmithControl
 
-    include Logger
 
     def initialize(options={})
       log_level((options[:log_level_given]) ? options[:log_level].to_sym : :info)
@@ -31,32 +32,28 @@ module Smith
     private
 
     def smithctl_command(command, args, &blk)
-      responder = Messaging::Responder.new
-      responder.callback do |v|
-        blk.call(v)
-      end
-
-      Command.run(command, args, :responder => responder)
+      Command.run(command, args, :responder => EM::Completion.new.tap { |c| c.completion(blk) })
     end
 
     def agency_command(command, args, &blk)
-      Messaging::Sender.new('agency.control', :auto_delete => false, :durable => false, :persistent => true,  :strict => true).ready do |sender|
+      Messaging::Sender.new(QueueDefinitions::Agency_control) do |sender|
 
-        sender.timeout(@timeout) { blk.call("Timeout. Is the agency still running?") }
+        timeout = Messaging::Timeout.new(5) { |message_id| blk.call("Timeout. Is the agency still running?") }
 
-        payload = ACL::Payload.new(:agency_command).content(:command => command, :args => args)
-
-        callback = proc do |sender|
-          sender.publish_and_receive(payload) do |r|
-            blk.call(r.payload)
-          end
+        sender.on_reply(:timeout => timeout) do |reply_payload, r|
+          r.ack
+          blk.call(reply_payload[:response])
         end
 
-        errback = proc do
-          blk.call("Agency not running.")
-        end
+        # callback = proc do |sender|
+          sender.publish(Smith::ACL::Factory.create(:agency_command, :command => command, :args => args))
+        # end
+
+        # errback = proc do
+        #   blk.call("Agency not running.")
+        # end
 
-        sender.consumers?(callback, errback)
+        # sender.consumers?(callback, errback)
       end
     end
   end

data/lib/smith.rb

@@ -1,6 +1,7 @@
 # -*- encoding: utf-8 -*-
 require 'amqp'
 require 'tmpdir'
+require "socket"
 require 'logging'
 require 'pathname'
 require 'fileutils'
@@ -21,9 +22,9 @@ module Smith
 
   class << self
 
-    def channel
-      raise RuntimeError, "You must run this in a Smith.start block" if @channel.nil?
-      @channel
+    def connection
+      raise RuntimeError, "You must run this in a Smith.start block" if @connection.nil?
+      @connection
     end
 
     def environment
@@ -42,6 +43,11 @@ module Smith
       path_to_pathnames(config.agency.agent_path)
     end
 
+    # Convenience method to get the hostname
+    def hostname
+      Socket.gethostname
+    end
+
     def acl_path
       path_to_pathnames(config.agency.acl_path)
     end
@@ -81,23 +87,12 @@ module Smith
       EM.reactor_running?
     end
 
-    # Define a channel error handler.
-    def on_error(chain=false, &blk)
-      # This strikes me as egregiously wrong but I don't know how to
-      # overwrite an already existing handler.
-      if chain
-        Smith.channel.callbacks[:error] << blk
-      else
-        Smith.channel.callbacks[:error] = [blk]
-      end
-    end
-
     def start(opts={}, &block)
       EM.epoll if EM.epoll?
       EM.kqueue if EM.kqueue?
       EM.set_descriptor_table_size(opts[:fdsize] || 1024)
 
-      connection_settings = config.amqp.broker._merge(
+      connection_settings = config.amqp.broker.to_hash.merge(
         :on_tcp_connection_failure => method(:tcp_connection_failure_handler),
         :on_possible_authentication_failure => method(:authentication_failure_handler))
 
@@ -121,15 +116,16 @@ module Smith
           logger.info { "Connection to AMQP server restored" }
         end
 
-        connection.on_error do |connection, reason|
-          case reason.reply_code
+        connection.on_error do |connection, connection_close|
+          case connection_close.reply_code
           when 320
             logger.warn { "AMQP server shutdown. Waiting." }
           else
             if @handler
               @handler.call(connection, reason)
             else
-              logger.error { "AMQP Server error: #{reason.reply_code}: #{reason.reply_text}" }
+              logger.error { "AMQP Server error: #{connection_close.reply_code}: #{connection_close.reply_text}" }
+              EM.stop_event_loop
             end
           end
         end
@@ -137,25 +133,7 @@ module Smith
         # This will be the last thing run by the reactor.
         shutdown_hook { logger.debug { "Reactor Stopped" } }
 
-        AMQP::Channel.new(connection) do |channel,ok|
-          @channel = channel
-          # Set up QOS. If you do not do this then the subscribe in receive_message
-          # will get overwhelmed and the whole thing will collapse in on itself.
-          channel.prefetch(1)
-
-          # Set up a default handler.
-          on_error do |ch,channel_close|
-            logger.fatal { "Channel level exception: #{channel_close.reply_code}: #{channel_close.reply_text}" }
-            logger.fatal { "Exiting" }
-            Smith.stop(true)
-          end
-
-          # Set up auto-recovery. This will ensure that the AMQP gem reconnects each
-          # channel and sets up the various exchanges & queues.
-          channel.auto_recovery = true
-
-          block.call
-        end
+        block.call
       end
     end
 
@@ -168,7 +146,9 @@ module Smith
 
       if running?
         if immediately
-          @connection.close { EM.stop_event_loop }
+          EM.next_tick do
+            @connection.close { EM.stop_event_loop }
+          end
         else
           EM.add_timer(1) do
             @connection.close { EM.stop_event_loop }
@@ -221,22 +201,26 @@ module Smith
   end
 end
 
+require_relative 'smith/amqp_errors'
 require_relative 'smith/object_count'
 require_relative 'smith/cache'
-require_relative 'smith/agent'
 require_relative 'smith/agent_cache'
 require_relative 'smith/agent_process'
 require_relative 'smith/agent_monitoring'
 require_relative 'smith/command'
 require_relative 'smith/command_base'
 require_relative 'smith/exceptions'
+require_relative 'smith/object_count'
 require_relative 'smith/version'
 
+require_relative 'smith/messaging/queue_definition'
 require_relative 'smith/messaging/amqp_options'
 require_relative 'smith/messaging/queue_factory'
-require_relative 'smith/messaging/payload'
 require_relative 'smith/messaging/acl/default'
-require_relative 'smith/messaging/endpoint'
+require_relative 'smith/messaging/payload'
+require_relative 'smith/messaging/util'
 require_relative 'smith/messaging/responder'
 require_relative 'smith/messaging/receiver'
 require_relative 'smith/messaging/sender'
+
+require_relative 'smith/queue_definitions'

data/lib/smith/agent.rb

@@ -17,22 +17,54 @@ module Smith
       @signal_handlers = Hash.new { |h,k| h[k] = Array.new }
 
       setup_control_queue
-      setup_stats_queue
 
       @start_time = Time.now
 
-      on_started do
-        logger.info { "#{name}:[#{pid}] started." }
+      @state = :starting
+
+      @on_stopping = proc {|completion| completion.succeed }
+      @on_starting = proc {|completion| completion.succeed }
+      @on_running = proc {|completion| completion.succeed }
+
+      @on_starting_completion = EM::Completion.new.tap do |c|
+        c.completion do |completion|
+          acknowledge_start do
+            @on_running.call(@on_running_completion)
+            logger.info { "Agent started: #{name}:[#{pid}]." }
+          end
+        end
+      end
+
+      @on_running_completion = EM::Completion.new.tap do |c|
+        c.completion do |completion|
+          start_keep_alive
+          setup_stats_queue
+          @state = :running
+        end
       end
 
-      on_stopped do
-        logger.info { "#{name}:[#{pid}] stopped." }
+      @on_stopping_completion = EM::Completion.new.tap do |c|
+        c.completion do |completion|
+          acknowledge_stop do
+            @state = :stopping
+            Smith.stop do
+              logger.info { "Agent stopped: #{name}:[#{pid}]." }
+            end
+          end
+        end
       end
 
       EM.threadpool_size = 1
 
-      acknowledge_start
-      start_keep_alive
+      @on_starting.call(@on_starting_completion)
+    end
+
+    def on_stopping(&blk)
+      @on_stopping = blk
+    end
+
+    def on_running(&blk)
+      @on_running = blk
     end
 
     # Override this method to implement your own agent. You can use task but this may
@@ -47,14 +79,6 @@ module Smith
       end
     end
 
-    def on_started(&blk)
-      @on_started = blk
-    end
-
-    def on_stopped(&blk)
-      Smith.shutdown_hook(&blk)
-    end
-
     def install_signal_handler(signal, position=:end, &blk)
       raise ArgumentError, "Unknown position: #{position}" if ![:beginning, :end].include?(position)
 
@@ -65,20 +89,21 @@ module Smith
       end
     end
 
-    def started
-      @on_started.call
+    def state
+      @state
     end
 
-    def receiver(queue_name, opts={})
-      queues.receiver(queue_name, opts) do |receiver|
-        receiver.subscribe do |r|
-          yield r
-        end
-      end
+    # Set convenience state methods.
+    [:starting, :stopping, :running].each do |method|
+      define_method("#{method}?", proc { state == method })
+    end
+
+    def receiver(queue_name, opts={}, &blk)
+      queues.receiver(queue_name, opts, &blk)
     end
 
-    def sender(queue_name, opts={})
-      queues.sender(queue_name, opts) { |sender| yield sender }
+    def sender(queue_name, opts={}, &blk)
+      queues.sender(queue_name, opts, &blk)
     end
 
     class << self
@@ -104,56 +129,59 @@ module Smith
 
     def setup_control_queue
       logger.debug { "Setting up control queue: #{control_queue_name}" }
-      receiver(control_queue_name, :auto_delete => true, :durable => false) do |r|
-        logger.debug { "Command received on agent control queue: #{r.payload.command} #{r.payload.options}" }
-
-        case r.payload.command
-        when 'object_count'
-          object_count(r.payload.options.first.to_i).each{|o| logger.info{o}}
-        when 'stop'
-          acknowledge_stop { Smith.stop }
-        when 'log_level'
-          begin
-            level = r.payload.options.first
-            logger.info { "Setting log level to #{level} for: #{name}" }
-            log_level(level)
-          rescue ArgumentError => e
-            logger.error { "Incorrect log level: #{level}" }
+
+      Messaging::Receiver.new(control_queue_name, :durable => false, :auto_delete => true) do |receiver|
+        receiver.subscribe do |payload|
+          logger.debug { "Command received on agent control queue: #{payload.command} #{payload.options}" }
+
+          case payload.command
+          when 'object_count'
+            object_count(payload.options.first.to_i).each{|o| logger.info{o}}
+          when 'stop'
+            @on_stopping.call(@on_stopping_completion)
+          when 'log_level'
+            begin
+              level = payload.options.first
+              logger.info { "Setting log level to #{level} for: #{name}" }
+              log_level(level)
+            rescue ArgumentError => e
+              logger.error { "Incorrect log level: #{level}" }
+            end
+          else
+            logger.warn { "Unknown command: #{level} -> #{level.inspect}" }
           end
-        else
-          logger.warn { "Unknown command: #{level} -> #{level.inspect}" }
         end
       end
     end
 
     def setup_stats_queue
+      puts "setting stats"
       # instantiate this queue without using the factory so it doesn't show
       # up in the stats.
-      sender('agent.stats', :dont_cache => true, :durable => false, :auto_delete => false) do |stats_queue|
+      Messaging::Sender.new(QueueDefinitions::Agent_stats) do |stats_queue|
         EventMachine.add_periodic_timer(2) do
-          callback = proc do |consumers|
-            payload = ACL::Payload.new(:agent_stats).content do |p|
-              p.agent_name = self.name
-              p.pid = self.pid
-              p.rss = (File.read("/proc/#{pid}/statm").split[1].to_i * 4) / 1024 # This assumes the page size is 4K & is MB
-              p.up_time = (Time.now - @start_time).to_i
-              factory.each_queue do |q|
-                p.queues << ACL::AgentStats::QueueStats.new(:name => q.denormalized_queue_name, :type => q.class.to_s, :length => q.counter)
+          stats_queue.number_of_consumers do |consumers|
+            if consumers > 0
+              payload = ACL::Factory.create(:agent_stats) do |p|
+                p.agent_name = self.name
+                p.pid = self.pid
+                p.rss = (File.read("/proc/#{pid}/statm").split[1].to_i * 4) / 1024 # This assumes the page size is 4K & is MB
+                p.up_time = (Time.now - @start_time).to_i
+                factory.each_queue do |q|
+                  p.queues << ACL::Factory.create('agent_stats::queue_stats', :name => q.denormalised_queue_name, :type => q.class.to_s, :length => q.counter)
+                end
               end
-            end
 
-            stats_queue.publish(payload)
+              stats_queue.publish(payload)
+            end
           end
-
-          # The errback argument is set to nil so as to suppress the default message.
-          stats_queue.consumers?(callback, nil)
         end
       end
     end
 
-    def acknowledge_start
-      sender('agent.lifecycle', :auto_delete => false, :durable => false, :dont_cache => true) do |ack_start_queue|
-        payload = ACL::Payload.new(:agent_lifecycle).content do |p|
+    def acknowledge_start(&blk)
+      Messaging::Sender.new(QueueDefinitions::Agent_lifecycle) do |ack_start_queue|
+        payload = ACL::Factory.create(:agent_lifecycle) do |p|
           p.state = 'acknowledge_start'
           p.pid = $$
           p.name = self.class.to_s
@@ -162,24 +190,26 @@ module Smith
           p.singleton = Smith.config.agent.singleton
           p.started_at = Time.now.to_i
         end
-        ack_start_queue.publish(payload)
+        ack_start_queue.publish(payload, &blk)
       end
     end
 
-    def acknowledge_stop(&block)
-      sender('agent.lifecycle', :auto_delete => false, :durable => false, :dont_cache => true) do |ack_stop_queue|
+    def acknowledge_stop(&blk)
+      Messaging::Sender.new(QueueDefinitions::Agent_lifecycle) do |ack_stop_queue|
         message = {:state => 'acknowledge_stop', :pid => $$, :name => self.class.to_s}
-        ack_stop_queue.publish(ACL::Payload.new(:agent_lifecycle).content(message), &block)
+        ack_stop_queue.publish(ACL::Factory.create(:agent_lifecycle, message), &blk)
       end
     end
 
     def start_keep_alive
       if Smith.config.agent.monitor
         EventMachine::add_periodic_timer(1) do
-          sender('agent.keepalive', :auto_delete => false, :durable => false, :dont_cache => true) do |keep_alive_queue|
+          Messaging::Sender.new(QueueDefinitions::Agent_keepalive) do |queue|
             message = {:name => self.class.to_s, :pid => $$, :time => Time.now.to_i}
-            keep_alive_queue.consumers? do |sender|
-              keep_alive_queue.publish(ACL::Payload.new(:agent_keepalive).content(message))
+            keep_alive_queue.consumers do |consumers|
+              if consumers > 0
+                keep_alive_queue.publish(ACL::Factory.create(:agent_keepalive, message))
+              end
             end
           end
         end

data/lib/smith/agent_monitoring.rb

@@ -36,10 +36,9 @@ module Smith
               logger.info { "Agent is shutting down: #{agent_process.name}" }
             when 'dead'
               logger.info { "Restarting dead agent: #{agent_process.name}" }
-              Messaging::Sender.new('agency.control', :auto_delete => false, :durable => false, :strict => true).ready do |sender|
-                sender.publish_and_receive(ACL::Payload.new(:agency_command).content(:command => 'start', :args => [agent_process.name])) do |r|
-                  logger.debug { "Agent restart message acknowledged: #{agent_process.name}" }
-                end
+              Messaging::Sender.new(QueueDefinitions::Agency_control) do |sender|
+                sender.on_reply { |p, r| logger.debug { "Agent restart message acknowledged: #{agent_process.name}" } }
+                sender.publish(ACL::Factory.create(:agency_command).content(:command => 'start', :args => [agent_process.name]))
               end
             when 'unknown'
               logger.info { "Agent is in an unknown state: #{agent_process.name}" }