smith 0.5.8 → 0.5.10

data/lib/smith/agent_monitoring.rb

@@ -17,26 +17,26 @@ module Smith
             when 'running'
               if agent_process.last_keep_alive
                 if agent_process.last_keep_alive > agent_process.started_at
-                  if (Time.now.utc.to_i - agent_process.last_keep_alive) > 10
+                  if (Time.now.to_i - agent_process.last_keep_alive) > 10
                     logger.fatal { "Agent not responding: #{agent_process.name}" }
                     agent_process.no_process_running
                   end
                 else
-                  logger.warn { "Discarding keep_alives with timestamp before agent started: #{Time.at(agent_process.started_at)} > #{Time.at(agent_process.last_keep_alive)}" }
+                  logger.warn { "Discarding keepalives with timestamp before agent started: #{Time.at(agent_process.started_at)} > #{Time.at(agent_process.last_keep_alive)}" }
                 end
               end
             when 'starting'
-              if (Time.now.utc.to_i - agent_process.started_at) > 10
+              if (Time.now.to_i - agent_process.started_at) > 10
                 logger.error { "No response from agent for > 10 seconds. Agent probably didn't start" }
                 agent_process.not_responding
               else
                 logger.debug { "no keep alive from #{agent_process.name}" }
               end
-            when 'stoping'
+            when 'stopping'
               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 => true, :durable => false, :strict => true).ready do |sender|
+              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

data/lib/smith/agent_process.rb

@@ -15,7 +15,7 @@ module Smith
     property :path,             String, :required => true
     property :name,             String, :required => true
     property :state,            String, :required => true
-    property :pid,              String
+    property :pid,              Integer
     property :started_at,       Integer
     property :last_keep_alive,  Integer
     property :metadata,         String
@@ -95,7 +95,7 @@ module Smith
     # Start an agent. This forks and execs the bootstrapper class
     # which then becomes responsible for managing the agent process.
     def self.start(agent_process)
-      agent_process.started_at = Time.now.utc
+      agent_process.started_at = Time.now
       agent_process.pid = fork do
 
         # Detach from the controlling terminal
@@ -115,9 +115,9 @@ module Smith
         STDIN.reopen("/dev/null")
         STDERR.reopen(STDOUT)
 
-        bootstraper = File.expand_path(File.join(File.dirname(__FILE__), 'bootstrap.rb'))
+        bootstrapper = File.expand_path(File.join(File.dirname(__FILE__), 'bootstrap.rb'))
 
-        exec('ruby', bootstraper, agent_process.path, agent_process.name, Smith.acl_cache_path.to_s)
+        exec('ruby', bootstrapper, agent_process.path, agent_process.name, Smith.acl_cache_path.to_s)
       end
 
       # We don't want any zombies.

data/lib/smith/application/agency.rb

@@ -15,7 +15,7 @@ module Smith
     end
 
     def setup_queues
-      Messaging::Receiver.new('agency.control', :auto_delete => true, :durable => false, :strict => true).ready do |receiver|
+      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.
@@ -23,14 +23,14 @@ module Smith
 
             begin
               Command.run(r.payload.command, r.payload.args, :agency => self,  :agents => @agent_processes, :responder => responder)
-            rescue Command::UnkownCommandError => e
+            rescue Command::UnknownCommandError => e
               responder.value("Unknown command: #{r.payload.command}")
             end
           end
         end
       end
 
-      Messaging::Receiver.new('agent.lifecycle', :auto_delete => true, :durable => false).ready do |receiver|
+      Messaging::Receiver.new('agent.lifecycle', :auto_delete => false, :durable => false).ready do |receiver|
         receiver.subscribe do |r|
           case r.payload.state
           when 'dead'
@@ -40,12 +40,12 @@ module Smith
           when 'acknowledge_stop'
             acknowledge_stop(r.payload)
           else
-            logger.warn { "Unkown command received on agent.lifecycle queue: #{r.payload.state}" }
+            logger.warn { "Unknown command received on agent.lifecycle queue: #{r.payload.state}" }
           end
         end
       end
 
-      Messaging::Receiver.new('agent.keepalive', :auto_delete => true, :durable => false).ready do |receiver|
+      Messaging::Receiver.new('agent.keepalive', :auto_delete => false, :durable => false).ready do |receiver|
         receiver.subscribe do |r|
           keep_alive(r.payload)
         end
@@ -59,8 +59,12 @@ module Smith
 
     # Stop the agency. This will wait for one second to ensure
     # that any messages are flushed.
-    def stop
-      Smith.stop(true)
+    def stop(&blk)
+      if blk
+        Smith.stop(true, &blk)
+      else
+        Smith.stop(true)
+      end
     end
 
     private

data/lib/smith/bootstrap.rb

@@ -84,7 +84,7 @@ module Smith
 
     def send_dead_message
       logger.debug { "Sending dead message to agency: #{@agent_name}" }
-      Messaging::Sender.new('agent.lifecycle', :auto_delete => true, :durable => false).ready do |sender|
+      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))
       end
     end
@@ -137,10 +137,10 @@ Smith.load_acls
 
 bootstrapper = Smith::AgentBootstrap.new(path, agent_name)
 
-# I've tried putting the exception handling in the main reactor loog
-# but it doesn't do anything. I know theres a resaon for this but I
+# I've tried putting the exception handling in the main reactor log
+# but it doesn't do anything. I know there's a reason for this but I
 # don't what it is at the moment. Just beware that whenever there
-# is an exception the recator is not going going to be running.
+# is an exception the reactor is not going going to be running.
 begin
   Smith.start do
     bootstrapper.load_agent

data/lib/smith/command.rb

@@ -4,7 +4,7 @@ require 'trollop'
 
 module Smith
   class Command
-    class UnkownCommandError < RuntimeError; end
+    class UnknownCommandError < RuntimeError; end
 
     include Logger
 
@@ -17,12 +17,12 @@ module Smith
     def self.run(command, args, vars)
       # Change _ to - underscores look so ugly as a command name.
       command = command.gsub(/-/, '_')
-      logger.debug { "Agency command: #{command}#{(args.empty?) ? '' : " #{args.join(', ')}"}." }
-
       load_command(command)
 
       clazz = Commands.const_get(Extlib::Inflection.camelize(command)).new
 
+      logger.debug { "#{(Command.agency?) ? 'Agency' : 'Smithctl'} command: #{command}#{(args.empty?) ? '' : " #{args.join(', ')}"}." }
+
       begin
 
         clazz.parse_options(args)
@@ -62,17 +62,34 @@ module Smith
       when smithctl_command?(command)
         :smithctl
       else
-        raise UnkownCommandError, "Unknown command: #{command}"
+        raise UnknownCommandError, "Unknown command: #{command}"
       end
     end
 
-    private
+    def self.commands(type=:all)
+      types = case type
+      when :all
+        ['agency', 'smithctl']
+      when :agency
+        types = ['agency']
+      when :smithctl
+        types = ['smithctl']
+      else
+        raise ArgumentError, "Unknown command type"
+      end
+
+      types.map do |type|
+        Pathname.glob(base_path.join(type).join("**/*.rb"))
+      end.flatten.map {|p| to_command_name(p) }
+    end
 
     # Check to see if the command is an agency or smithctl command.
     def self.agency?
       Smith.constants.include?(:Agency)
     end
 
+    private
+
     # Return the full path of the ruby class.
     def self.command_path(command)
       send("#{command_type(command)}_path").join(command)
@@ -98,6 +115,10 @@ module Smith
       base_path.join('smithctl')
     end
 
+    def self.to_command_name(path)
+      path.basename(".rb").to_s
+    end
+
     # Return the command base path.
     def self.base_path
       @c64a6f4f ||= Smith.root_path.join('lib').join("smith").join('commands')

data/lib/smith/command_base.rb

@@ -55,9 +55,9 @@ module Smith
   #{text}
 
   Usage:
-    smithctl #{self.class.to_s.split('::').last.downcase} OPTIONS
+    smithctl #{self.class.to_s.split('::').last.downcase} [Options]
 
-OPTIONS are:
+[Options] are:
       EOS
     end
   end

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

@@ -4,41 +4,26 @@ module Smith
     class List < CommandBase
       def execute
         responder.value do
-          if options[:all]
-            if agents.empty?
-              "No agents running."
-            else
-              if options[:long]
-                tabulate(long_format(agents), :header => "total #{agents.count}")
-              else
-                short_format(agents)
-              end
-            end
-          else
-            running_agents = agents.state(:running)
-            if running_agents.empty?
-              "No agents running."
-            else
-              if options[:long]
-                tabulate(long_format(running_agents), :header => "total #{running_agents.count}")
-              else
-                short_format(running_agents)
-              end
-            end
-          end
+          a = (options[:all]) ? agents : agents.state(:running)
+          (a.empty?) ? nil : format(a, options[:long])
         end
       end
 
       private
 
-      def long_format(agents)
-        agents.map do |a|
+      def format(a, long)
+        a = (target.empty?) ? a : a.select {|z| target.detect {|y| z.name == y } }.flatten
+        (long) ? tabulate(long_format(a), :header => "total #{a.count}") : short_format(a)
+      end
+
+      def long_format(a)
+        a.map do |a|
           [a.state, a.pid, (a.started_at) ? format_time(a.started_at) : '', (!(a.stopped? || a.null?) && !a.alive?) ? '(agent dead)' : "", a.name]
         end
       end
 
-      def short_format(agents)
-        agents.map(&:name).sort.join(" ")
+      def short_format(a)
+        a.map(&:name).sort.join(" ")
       end
 
       def format_time(t)

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

@@ -39,7 +39,7 @@ module Smith
       private
 
       def send_agent_control_message(agent, message)
-        Messaging::Sender.new(agent.control_queue_name, :durable => false, :auto_delete => true).ready do |sender|
+        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))
         end
       end

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

@@ -12,7 +12,7 @@ module Smith
       include Common
 
       def execute
-        Messaging::Sender.new('agency.control', :auto_delete => true, :durable => false, :strict => true).ready do |sender|
+        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|

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

@@ -9,15 +9,17 @@ module Smith
       include Common
 
       def execute
+
+        #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        #!!!!!!!!!!!! See not 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
-            # I don't understand why I need to put self here. target= is a method
-            # on Command so I would have thought that would be used but a local
-            # variable is used instead of the method. TODO work out why and fix.
-            self.target = agent_group(options[:group])
-            if target.empty?
+            agents_to_start = agent_group(options[:group])
+            if agents_to_start.empty?
               responder.value("There are no agents in group: #{options[:group]}")
               return
             end
@@ -25,13 +27,15 @@ module Smith
             responder.value(e.message)
             return
           end
+        else
+          agents_to_start = target
         end
 
         responder.value do
-          if target.empty?
+          if agents_to_start.empty?
             "Start what? No agent specified."
           else
-            target.map do |agent|
+            agents_to_start.map do |agent|
               agents[agent].name = agent
               if agents[agent].path
                 if options[:kill]
@@ -60,3 +64,12 @@ module Smith
     end
   end
 end
+
+
+# A note about target.
+#
+# 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
+# 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,6 +9,11 @@ module Smith
       include Common
 
       def execute
+
+        #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        #!!!!!!!!!!!! See not about target at end of this file !!!!!!!!!!!!!!
+        #!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
         case target.first
         when 'agency'
           running_agents = agents.state(:running)
@@ -31,11 +36,8 @@ module Smith
           # any other specified agents.
           if options[:group]
             begin
-              # I don't understand why I need to put self here. target= is a method
-              # on Command so I would have thought that would be used but a local
-              # variable is used instead of the method. TODO work out why and fix.
-              self.target = agent_group(options[:group])
-              if target.empty?
+              agents_to_stop = agent_group(options[:group])
+              if agents_to_stop.empty?
                 responder.value("There are no agents in group: #{options[:group]}")
                 return
               end
@@ -43,16 +45,18 @@ module Smith
               responder.value(e)
               return
             end
+          else
+            agents_to_stop = target
           end
 
-          ret = target.inject([]) do |acc,agent_name|
+          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
+                   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(", ")}")
         end
@@ -68,3 +72,12 @@ module Smith
     end
   end
 end
+
+
+# A note about target.
+#
+# 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
+# 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/version.rb

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+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.
+        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
+          end
+        else
+          responder.value(Smith::VERSION)
+        end
+      end
+
+      private
+
+      def options_spec
+        banner "Display the agency version."
+
+        opt    :git, "run git describe, assuming git is installed", :short => :g
+      end
+    end
+  end
+end