smith 0.5.7

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

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+module Smith
+  module Commands
+    class Agents < Command
+      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
+            end
+          end.flatten
+          (agent_paths.empty?) ? "" : agent_paths.sort.join(" ")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+module Smith
+  module Commands
+    module Common
+      def agent_group(group)
+        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)}
+          else
+            raise RuntimeError, "Group does not exist: #{group}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# -*- encoding: utf-8 -*-
+module Smith
+  module Commands
+    class Kill < Command
+      def execute
+        target.each do |agent_name|
+          agents[agent_name].kill
+        end
+        responder.value
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# -*- encoding: utf-8 -*-
+module Smith
+  module Commands
+    class List < Command
+      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
+        end
+      end
+
+      def options_parser
+        Trollop::Parser.new do
+          banner  Command.banner('list')
+          opt     :long,                "the number of times to send the message", :short => :l
+          opt     :all,                 "show all agents in all states", :short => :a
+        end
+      end
+
+      private
+
+      def long_format(agents)
+        agents.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(" ")
+      end
+
+      def format_time(t)
+        (t) ? Time.at(t).strftime("%Y/%m/%d %H:%M:%S") : ''
+      end
+
+      def tabulate(a, opts={})
+        col_widths = a.transpose.map{|col| col.map{|cell| cell.to_s.length}.max}
+        header = (opts[:header]) ? "#{opts[:header]}\n" : ''
+        a.inject(header) do |acc,e|
+          acc << sprintf("#{col_widths.inject("") { |spec,w| spec << "%-#{w + 2}s"}}\n", *e)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# -*- encoding: utf-8 -*-
+module Smith
+  module Commands
+    class Logger < Command
+      def execute
+        responder.value do
+          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
+              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
+              end
+              nil
+            end
+          end
+        end
+      end
+
+      def options_parser
+        Trollop::Parser.new do
+          banner  Command.banner('logger')
+          opt     :level,               "the log level you want to set", :type => :string, :short => :l
+          opt     :trace,               "turn trace on or off", :type => :boolean, :short => :t
+        end
+      end
+
+      private
+
+      def send_agent_control_message(agent, message)
+        Messaging::Sender.new(agent.control_queue_name, :durable => false, :auto_delete => true).ready do |sender|
+          sender.publish(ACL::Payload.new(:agent_command).content(message))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# -*- encoding: utf-8 -*-
+module Smith
+  module Commands
+    class Metadata < Command
+      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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+
+# This is a meta-command. It doesn't implement anything it simply sends
+# messages to one or many existing commands to do the work.
+
+module Smith
+  module Commands
+    class Restart < Command
+
+      include Common
+
+      def execute
+        Messaging::Sender.new('agency.control', :auto_delete => true, :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
+            end
+          end
+        end
+      end
+
+
+      def options_parser
+        command = self.class.to_s.split(/::/).last.downcase
+        Trollop::Parser.new do
+          banner  Command.banner(command)
+          opt     :group,     "Start everything in the specified group", :type => :string, :short => :g
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+
+module Smith
+  module Commands
+    class Start < Command
+
+      include Common
+
+      def execute
+        # 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?
+              responder.value("There are no agents in group: #{options[:group]}")
+              return
+            end
+          rescue RuntimeError => e
+            responder.value(e.message)
+            return
+          end
+        end
+
+        responder.value do
+          if target.empty?
+            "Start what? No agent specified."
+          else
+            target.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
+              end
+            end.compact.join("\n")
+          end
+        end
+      end
+
+      def options_parser
+        command = self.class.to_s.split(/::/).last.downcase
+        Trollop::Parser.new do
+          banner  Command.banner(command)
+          opt     :kill,     "Reset the state of the agent before starting", :short => :k
+          opt     :group,     "Start everything in the specified group", :type => :string, :short => :g
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# -*- encoding: utf-8 -*-
+module Smith
+  module Commands
+    class State < Command
+      def execute
+        responder.value do
+          target.inject([]) do |acc,agent_name|
+            acc.tap { |a| a << ["#{agent_name}: #{agents[agent_name].state}"] }
+          end.join("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# -*- encoding: utf-8 -*-
+
+require_relative 'common'
+
+module Smith
+  module Commands
+    class Stop < Command
+
+      include Common
+
+      def execute
+        case target.first
+        when 'agency'
+          running_agents = agents.state(:running)
+          if running_agents.empty?
+            logger.info { "Agency shutting down." }
+            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(", ")}.")
+          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
+              # 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?
+                responder.value("There are no agents in group: #{options[:group]}")
+                return
+              end
+            rescue RuntimeError => e
+              responder.value(e)
+              return
+            end
+          end
+
+          ret = target.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(", ")}")
+        end
+      end
+
+      def options_parser
+        command = self.class.to_s.split(/::/).last.downcase
+        Trollop::Parser.new do
+          banner  Command.banner(command)
+          opt     :group,     "Stop everything in the specified group", :type => :string, :short => :g
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+module Smith
+  module Commands
+    class Version < Command
+      def execute
+        version_file = Smith.root_path.join('VERSION')
+
+        if options[:git] || !version_file.exist?
+          responder.value("#{(`git describe` rescue '').strip}")
+        else
+          responder.value(version_file.read.strip)
+        end
+      end
+
+      def options_parser
+        Trollop::Parser.new do
+          banner  Command.banner('version')
+          opt     :git, "run git describe, assuming git is installed", :short => :g
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# -*- encoding: utf-8 -*-
+
+require 'multi_json'
+
+module Smith
+  module Commands
+    class Cat < Command
+      def execute
+        if target.size == 0
+          responder.value("No queue specified. Please specify a queue.")
+          Smith.stop(true)
+        else
+          begin
+            data = case
+                   when options[:json_given]
+                     options[:json]
+                   when options[:file_given]
+                     file = Pathname.new(options[:file])
+                     if file.exist?
+                       file.read
+                     else
+                       responder.value("File does not exist: #{file.display}")
+                     end
+                   end
+
+            Smith::Messaging::Sender.new(target.first, :auto_delete => options[:dynamic], :persistent => true, :nowait => false, :strict => true).ready do |sender|
+
+              work = proc do |n,iter|
+                sender.publish(json_to_payload(data, options[:type])) do
+                  iter.next
+                end
+              end
+
+              done = proc do
+                responder.value
+              end
+
+              EM::Iterator.new(0..options[:number] - 1).each(work, done)
+
+            end
+          rescue MultiJson::DecodeError => e
+            responder.value(e)
+            Smith.stop
+          end
+        end
+      end
+
+      def options_parser
+        Trollop::Parser.new do
+          banner  Command.banner('cat')
+          opt :type,     "message type", :type => :string, :default => 'default', :short => :t
+          opt :json,     "supply the json representation with this flag", :type => :string, :conflicts => :file, :short => :j
+          opt :file,     "read the data from the named file", :type => :string, :conflicts => :json, :short => :f
+          opt :number,   "the number of times to send the message", :type => :integer, :default => 1, :short => :n
+          opt :dynamic,  "send message to a dynamic queue", :type => :boolean, :default => false, :short => :d
+        end
+      end
+
+      private
+
+      def json_to_payload(data, type)
+        Smith::ACL::Payload.new(type.to_sym).content do |m|
+          MultiJson.decode(data, :symbolize_keys => true).each do |k,v|
+            m.send("#{k}=".to_sym, v)
+          end
+        end
+      end
+    end
+  end
+end