smith 0.5.8 → 0.5.10

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

@@ -3,14 +3,10 @@ module Smith
   module Commands
     class Commands < CommandBase
       def execute
-        commands = (target.empty?) ? list_commands('agency') + list_commands('smithctl') : target
+        commands = (target.empty?) ? Command.commands : target
         responder.value(format(commands))
       end
 
-      def list_commands(type)
-        list_command_files(type).map {|command| to_command_name(command) }
-      end
-
       def format(commands)
         if options[:long]
           c = instantiate_commands(commands)
@@ -30,14 +26,6 @@ module Smith
 
       private
 
-      def list_command_files(type)
-        Pathname.glob(Command.base_path.join(type).join("**/*.rb"))
-      end
-
-      def to_command_name(path)
-        path.basename(".rb").to_s
-      end
-
       def instantiate_commands(commands)
         commands.sort.inject({}) do |a, command|
           a.tap do |acc|

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

@@ -9,36 +9,44 @@ module Smith
         when 0
           responder.value("No queue specified. Please specify a queue.")
         when 1
-          Messaging::Receiver.new(target.shift, :auto_ack => false).ready do |receiver|
+
+          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::Receiver.new(queue, :auto_ack => false, :passive => true).ready do |receiver|
             callback = proc do
-              work = proc do |n,iter|
+              work = proc do |acc,n,iter|
                 receiver.pop do |r|
-                  iter.return(r)
+                  if options[:remove]
+                    r.ack
+                  else
+                    r.reject(:requeue => true)
+                  end
+
+                  acc[:result] << print_message(r.payload) if options[:print]
+                  acc[:count] += 1
+
+                  iter.return(acc)
                 end
               end
 
-              finished = proc do |result|
+              finished = proc do |acc|
                 responder.value do
-                  if options[:remove]
-                    logger.debug { "Removing #{result.size} message from #{result.first.queue_name}" }
-                    result.inject([]) do |a,r|
-                      a.tap do |acc|
-                        r.ack
-                        acc << print_message(r.payload)
-                      end
-                    end
-                  else
-                    result.inject([]) do |a,r|
-                      a.tap do |acc|
-                        r.reject(:requeue => true)
-                        acc << print_message(r.payload)
-                      end
-                    end
-                  end.join("\n")
+                  logger.debug { "Removing #{acc[:count]} message from #{receiver.queue_name}" }
+                  acc[:result].join("\n")
                 end
               end
 
-              EM::Iterator.new(0..options[:number] - 1).map(work, finished)
+              EM::Iterator.new(0..options[:number] - 1).inject({:count => 0, :result => []}, work, finished)
             end
 
             errback = proc {responder.value(nil)}
@@ -46,19 +54,17 @@ module Smith
             receiver.messages?(callback, errback)
           end
         else
-          responder.value("You can only specifiy one queue at a time")
+          responder.value("You can only specify one queue at a time")
         end
       end
 
       private
 
       def print_message(message)
-        if options[:print]
-          if options[:json]
-            message.as_json
-          else
-            message.inspect
-          end
+        if options[:json]
+          message.as_json
+        else
+          message.inspect
         end
       end
 

data/lib/smith/commands/smithctl/{cat.rb → push.rb}

@@ -4,7 +4,7 @@ require 'multi_json'
 
 module Smith
   module Commands
-    class Cat < CommandBase
+    class Push < CommandBase
       def execute
         if target.size == 0
           responder.value("No queue specified. Please specify a queue.")
@@ -23,7 +23,7 @@ module Smith
                      end
                    end
 
-            Smith::Messaging::Sender.new(target.first, :auto_delete => options[:dynamic], :persistent => true, :nowait => false, :strict => true).ready do |sender|
+            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
@@ -48,7 +48,7 @@ module Smith
       private
 
       def json_to_payload(data, type)
-        Smith::ACL::Payload.new(type.to_sym).content do |m|
+        ACL::Payload.new(type.to_sym).content do |m|
           MultiJson.load(data, :symbolize_keys => true).each do |k,v|
             m.send("#{k}=".to_sym, v)
           end

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

@@ -7,6 +7,17 @@ module Smith
         when 0
           responder.value("No queue specified. Please specify a queue.")
         else
+          Smith.on_error do |ch,channel_close|
+            case channel_close.reply_code
+            when 404
+              responder.value("No such queue: #{extract_queue(channel_close.reply_text)}")
+            when 406
+              responder.value("Queue not empty: #{extract_queue(channel_close.reply_text)}. Use -f to force remove")
+            else
+              responder.value("Unknown error: #{channel_close.reply_text}")
+            end
+          end
+
           target.each do |queue_name|
             Smith.channel.queue("smith.#{queue_name}", :passive => true) do |queue|
               queue_options = (options[:force]) ? {} : {:if_unused => true, :if_empty => true}
@@ -26,6 +37,15 @@ module Smith
         opt    :force,   "force the removal even if there are messages on the queue", :short => :f
         opt    :verbose, "print the number of messages deleted", :short => :v
       end
+
+      def extract_queue(message)
+        match = /.*?'(.*?)'.*$/.match(message) #[1]
+        if match && match[1]
+          match[1].sub(/smith\./, '')
+        else
+          message
+        end
+      end
     end
   end
 end

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

@@ -9,7 +9,7 @@ module Smith
         Curses.init_screen()
         win = Curses::Window.new(Curses.lines, Curses.cols, 0, 0)
 
-        Smith::Messaging::Receiver.new('agent.stats', :durable => false, :auto_delete => false).ready do |receiver|
+        Messaging::Receiver.new('agent.stats', :durable => false, :auto_delete => false).ready do |receiver|
           receiver.subscribe do |r|
             payload = r.payload
             win.setpos(0,0)

data/lib/smith/config.rb

@@ -3,6 +3,16 @@ module Smith
   class Config
 
     @@config = Optimism.new.tap do |o|
+      o.agency do |a|
+        a.timeout = 30
+      end
+
+      o.agent do |a|
+        a.monitor = false
+        a.singleton = true
+        a.metadata = ''
+      end
+
       o.amqp do |a|
         a.publish do |p|
           p.ack = true
@@ -12,6 +22,11 @@ module Smith
         a.pop.ack = true
         a.subscribe.ack = true
       end
+
+      o.agency do |a|
+        a.timeout = 30
+      end
+
       o.logging do |l|
         l.trace = false
         l.level = :debug

data/lib/smith/daemon.rb

@@ -0,0 +1,68 @@
+# -*- encoding: utf-8 -*-
+
+require 'daemons/daemonize'
+require 'daemons/pidfile'
+
+module Smith
+  class Daemon
+
+    include Logger
+
+    def initialize(name, daemonise, dir=nil)
+      @name = name
+      @daemonise = daemonise
+      @pid = Daemons::PidFile.new(pid_dir(dir), @name)
+    end
+
+    # Daemonise the process if the daemonise option is true, otherwise do nothing.
+    def daemonise
+      unlink_pid_file
+
+      if @daemonise
+        Daemonize::daemonize('/dev/null', @name)
+      else
+        $0 = @name
+      end
+
+      @pid.pid = Process.pid
+      logger.debug { "Pid file: #{@pid.filename}" }
+    end
+
+    # Check to see if the program is running. This checks for the existance
+    # of a pid file and if there is checks to see if the pid exists.
+    def running?
+      pid_files = Daemons::PidFile.find_files(@pid.dir, @name)
+
+      if pid_files.empty?
+        false
+      else
+        pid = File.read(pid_files.first).to_i
+        pid > 0 && Daemons::Pid.running?(pid)
+      end
+    end
+
+    def unlink_pid_file
+      p = Pathname.new(@pid.filename)
+      if p.exist?
+        logger.verbose { "Removing pid file." }
+        p.unlink
+      end
+    end
+
+    private
+
+    # Get the pid directory. This checks for the command line option,
+    # then the config and finally use the tmp directory.
+    def pid_dir(dir)
+      if dir
+        dir
+      else
+        if Smith.config.agency._has_key?(:pid_dir)
+          Smith.config.agency.pid_dir
+        else
+          Dir.tmpdir
+        end
+      end
+    end
+  end
+end

data/lib/smith/{messaging/exceptions.rb → exceptions.rb}

@@ -1,5 +1,11 @@
 # -*- encoding: utf-8 -*-
 module Smith
+  class UnknownEnvironmentError < RuntimeError
+    def initialize(message=nil)
+      super("Invalid environment: #{message || Smith.environment}")
+    end
+  end
+
   module Messaging
     class IncompletePayload < RuntimeError; end
     class IncorrectPayloadType < RuntimeError; end

data/lib/smith/logger.rb

@@ -22,9 +22,8 @@ module Smith
       @@__date_pattern = Smith::Config.get.logging.default_date_pattern
       @@__level = Smith::Config.get.logging.level
       @@__trace = Smith::Config.get.logging.trace
-      @@__appender = Smith::Config.get.logging.appender._data.tap do |appender|
-        appender[:type] = Logging::Appenders.const_get(Extlib::Inflection.camelize(appender.delete(:type)))
-      end
+      @@__appender = Smith::Config.get.logging.appender._data.clone
+      @@__appender[:type] = Logging::Appenders.const_get(Extlib::Inflection.camelize(Smith::Config.get.logging.appender.type))
 
       def log_level(level=nil)
         if level

data/lib/smith/messaging/acl/agent_keepalive.proto

@@ -1,6 +1,6 @@
 package Smith.ACL;
 message AgentKeepalive {
   required string name = 1;
-  optional string pid = 2;
-  optional string time = 3;
+  optional int64 pid = 2;
+  optional int64 time = 3;
 }

data/lib/smith/messaging/acl/agent_lifecycle.proto

@@ -4,9 +4,9 @@ package Smith.ACL;
 message AgentLifecycle {
   required string state = 1;
   required string name = 2;
-  optional string pid = 3;
+  optional int64 pid = 3;
   optional bool monitor = 4;
   optional bool singleton = 5;
   optional string metadata = 6;
-  optional string started_at = 7;
+  optional int64 started_at = 7;
 }

data/lib/smith/messaging/acl/default.rb

@@ -2,7 +2,7 @@
 module Smith
   module ACL
 
-    # Default message. This takes any objuct that can be marshalled. If
+    # Default message. This takes any object that can be marshalled. If
     # no content is passed in on the constructor then an the message is
     # assigned an empty Hash. method_missing is declared and will update
     # the hash.

data/lib/smith/messaging/endpoint.rb

@@ -4,10 +4,10 @@ module Smith
     class Endpoint
       include Logger
 
-      attr_accessor :denomalized_queue_name, :queue_name
+      attr_accessor :denormalized_queue_name, :queue_name
 
       def initialize(queue_name, options)
-        @denomalized_queue_name = queue_name
+        @denormalized_queue_name = queue_name
         @queue_name = normalise(queue_name)
         @message_counts = Hash.new(0)
         @options = options
@@ -22,7 +22,7 @@ module Smith
             logger.error { "Properties: #{metadata.properties}" }
           end
 
-          logger.verbose { "Creating queue: [queue]:#{denomalized_queue_name} [options]:#{options.queue}" }
+          logger.verbose { "Creating queue: [queue]:#{denormalized_queue_name} [options]:#{options.queue}" }
 
           Smith.channel.queue(queue_name, options.queue) do |queue|
             @queue = queue
@@ -50,7 +50,7 @@ module Smith
         @message_counts[queue_name]
       end
 
-      def messages?(blk=nil, err=proc {logger.debug { "No messages on #{@denomalized_queue_name}" } })
+      def messages?(blk=nil, err=proc {logger.debug { "No messages on #{@denormalized_queue_name}" } })
         number_of_messages do |n|
           if n > 0
             if blk.respond_to? :call
@@ -64,7 +64,7 @@ module Smith
         end
       end
 
-      def consumers?(blk=nil, err=proc {logger.debug { "Nothing listening on #{@denomalized_queue_name}" } })
+      def consumers?(blk=nil, err=proc {logger.debug { "Nothing listening on #{@denormalized_queue_name}" } })
         number_of_consumers do |n|
           if n > 0
             if blk.respond_to? :call

data/lib/smith/messaging/receiver.rb

@@ -21,7 +21,7 @@ module Smith
       def subscribe(&block)
         if !@queue.subscribed?
           opts = options.subscribe
-          logger.verbose { "Subscribing to: [queue]:#{denomalized_queue_name} [options]:#{opts}" }
+          logger.verbose { "Subscribing to: [queue]:#{denormalized_queue_name} [options]:#{opts}" }
           queue.subscribe(opts) do |metadata,payload|
             if payload
               if @payload_type.empty? || @payload_type.include?(metadata.type.to_sym)
@@ -33,7 +33,7 @@ module Smith
                 raise IncorrectPayloadType, "This queue can only accept the following payload types: #{@payload_type.to_a.to_s}"
               end
             else
-              logger.verbose { "Received null message on: #{denomalized_queue_name} [options]:#{opts}" }
+              logger.verbose { "Received null message on: #{denormalized_queue_name} [options]:#{opts}" }
             end
           end
         else
@@ -68,8 +68,8 @@ module Smith
       # to auto ack or not. This is because it can get called twice and we don't
       # want to ack more than once or an error will be thrown.
       def thread(reply, &block)
-        logger.verbose { "Threads: [queue]: #{denomalized_queue_name}: #{threading?}" }
-        logger.verbose { "auto_ack: [queue]: #{denomalized_queue_name}: #{auto_ack?}" }
+        logger.verbose { "Threads: [queue]: #{denormalized_queue_name}: #{threading?}" }
+        logger.verbose { "auto_ack: [queue]: #{denormalized_queue_name}: #{auto_ack?}" }
         if threading?
           EM.defer do
             block.call(reply)
@@ -81,7 +81,7 @@ module Smith
         end
       end
 
-      # I'm not terribly happy about this class. It's publicaly visable and it contains
+      # I'm not terribly happy about this class. It's publicly visible and it contains
       # some gross violations of Ruby's protection mechanism. I suspect it's an indication
       # of a more fundamental design flaw. I will leave it as is for the time being but
       # this really needs to be reviewed. FIXME review this class.
@@ -100,10 +100,10 @@ module Smith
 
           if undecoded_payload
             @payload = ACL::Payload.decode(undecoded_payload, metadata.type)
-            logger.verbose { "Received content on: [queue]: #{denomalized_queue_name}." }
-            logger.verbose { "Payload content: [queue]: #{denomalized_queue_name}, [metadata type]: #{metadata.type}, [message]: #{payload.inspect}" }
+            logger.verbose { "Received content on: [queue]: #{denormalized_queue_name}." }
+            logger.verbose { "Payload content: [queue]: #{denormalized_queue_name}, [metadata type]: #{metadata.type}, [message]: #{payload.inspect}" }
           else
-            logger.verbose { "Received nil content on: [queue]: #{denomalized_queue_name}." }
+            logger.verbose { "Received nil content on: [queue]: #{denormalized_queue_name}." }
             @payload = nil
             @nil_message = true
           end
@@ -122,7 +122,7 @@ module Smith
           else
             # Null responder. If a call on the responder is made log a warning. Something is wrong.
             responder.callback do |return_value|
-              logger.error { "You are responding to a message that has no reply_to on queue: #{denomalized_queue_name}." }
+              logger.error { "You are responding to a message that has no reply_to on queue: #{denormalized_queue_name}." }
               logger.verbose { "Queue options: #{@metadata.exchange}." }
             end
           end
@@ -159,8 +159,8 @@ module Smith
               o[:type] = metadata.type
             end
 
-            logger.verbose { "Requeuing to: #{denomalized_queue_name}. [options]: #{opts}" }
-            logger.verbose { "Requeuing to: #{denomalized_queue_name}. [message]: #{ACL::Payload.decode(@undecoded_payload, metadata.type)}" }
+            logger.verbose { "Requeuing to: #{denormalized_queue_name}. [options]: #{opts}" }
+            logger.verbose { "Requeuing to: #{denormalized_queue_name}. [message]: #{ACL::Payload.decode(@undecoded_payload, metadata.type)}" }
 
             @receiver.send(:exchange).publish(@undecoded_payload, opts)
           end
@@ -184,7 +184,7 @@ module Smith
         end
 
         def queue_name
-          denomalized_queue_name
+          denormalized_queue_name
         end
 
         private
@@ -193,16 +193,16 @@ module Smith
           if current_requeue_number < count
             method = "#{strategy}_strategy".to_sym
             if respond_to?(method, true)
-              cummulative_delay = send(method, delay)
-              @on_requeue.call(cummulative_delay, current_requeue_number + 1)
-              EM.add_timer(cummulative_delay) do
-                block.call(cummulative_delay, current_requeue_number + 1)
+              cumulative_delay = send(method, delay)
+              @on_requeue.call(cumulative_delay, current_requeue_number + 1)
+              EM.add_timer(cumulative_delay) do
+                block.call(cumulative_delay, current_requeue_number + 1)
               end
             else
               raise RuntimeError, "Unknown requeue strategy. #{method}"
             end
           else
-            @on_requeue_error.call(cummulative_delay, current_requeue_number)
+            @on_requeue_error.call(cumulative_delay, current_requeue_number)
           end
         end
 
@@ -218,8 +218,8 @@ module Smith
           delay * (current_requeue_number + 1)
         end
 
-        def denomalized_queue_name
-          @receiver.denomalized_queue_name
+        def denormalized_queue_name
+          @receiver.denormalized_queue_name
         end
 
         def normalised_queue_name