gilmour 0.3.4 → 0.4.1

data/lib/gilmour/responder.rb

@@ -4,13 +4,12 @@ require 'json'
 require 'logger'
 require_relative './waiter'
 
-# Top level module
 module Gilmour
+
   # The Responder module that provides the request and respond
   # DSL
   # The public methods in this class are available to be called
   # from the body of the handlers directly
-
   class Request
     attr_reader :topic, :body
 
@@ -20,6 +19,10 @@ module Gilmour
     end
   end
 
+  # Every request handler is executed in the context of a Responder
+  # object.
+  # This class contains methods to respond to requests as well as
+  # proxy methods for carrying out gilmour actions inside the handlers.
   class Responder
     LOG_SEPERATOR = '%%'
     LOG_PREFIX = "#{LOG_SEPERATOR}gilmour#{LOG_SEPERATOR}"
@@ -27,20 +30,21 @@ module Gilmour
     attr_reader :logger
     attr_reader :request
 
-    def fork_logger(io_writer)
+    def child_logger(writer) #:nodoc:
       logger = Logger.new(STDERR)
       loglevel =  ENV["LOG_LEVEL"] ? ENV["LOG_LEVEL"].to_sym : :warn
       logger.level = Gilmour::LoggerLevels[loglevel] || Logger::WARN
       logger.formatter = proc do |severity, datetime, progname, msg|
-        data = "#{LOG_PREFIX}#{severity}#{LOG_SEPERATOR}#{msg}"
-        io_writer.write(data+"\n")
-        io_writer.flush
+        data = JSON.generate(severity: severity, msg: msg)
+#        data = "#{LOG_PREFIX}#{severity}#{LOG_SEPERATOR}#{msg}"
+        writer.write(data+"\n")
+        writer.flush
         nil
       end
       logger
     end
 
-    def make_logger
+    def make_logger #:nodoc:
       logger = Logger.new(STDERR)
       loglevel =  ENV["LOG_LEVEL"] ? ENV["LOG_LEVEL"].to_sym : :warn
       logger.level = Gilmour::LoggerLevels[loglevel] || Logger::WARN
@@ -51,34 +55,38 @@ module Gilmour
       logger
     end
 
-    def initialize(sender, topic, data, backend, timeout=600, forked=false)
+    def initialize(sender, topic, data, backend, opts={}) #:nodoc:
       @sender = sender
       @request = Request.new(topic, data)
       @response = { data: nil, code: nil }
       @backend = backend
-      @timeout = timeout || 600
-      @multi_process = forked || false
-      @pipe = IO.pipe
-      @publish_pipe = IO.pipe
+      @timeout = opts[:timeout] || 600
+      @multi_process = opts[:fork] || false
+      @respond = opts[:respond]
+      @response_pipe = IO.pipe
+      @logger_pipe = IO.pipe
+      @command_pipe = IO.pipe
       @logger = make_logger()
+      @delayed_response = false
     end
 
-    def receive_data(data)
-      sender, res_data, res_code = JSON.parse(data)
+    def receive_data(data) #:nodoc:
+      sender, res_data, res_code, opts = JSON.parse(data)
+      res_code ||= 200 if @respond
       write_response(sender, res_data, res_code) if sender && res_code
     end
 
     # Called by parent
-    def write_response(sender, data, code)
+    def write_response(sender, data, code) #:nodoc:
+      return unless @respond
       if code >= 300 && @backend.report_errors?
         emit_error data, code
       end
-
       @backend.send_response(sender, data, code)
     end
 
-    # Adds a dynamic listener for _topic_
-    def add_listener(topic, &handler)
+    # proxy to base add_listener
+    def add_listener(topic, opts={}, &handler)
       if @multi_process
         GLogger.error "Dynamic listeners using add_listener not supported \
         in forked responder. Ignoring!"
@@ -87,6 +95,27 @@ module Gilmour
       @backend.add_listener(topic, &handler)
     end
 
+    # Proxy to register slot (see Backend#slot for details)
+    def slot(topic, opts={}, &handler)
+      if @multi_process
+        GLogger.error "Dynamic listeners using add_listener not supported \
+        in forked responder. Ignoring!"
+      end
+
+      @backend.slot(topic, opts, &handler)
+    end
+
+    # Proxy to register reply listener (see Backend#reply_to for details)
+    def reply_to(topic, opts={}, &handler)
+      if @multi_process
+        GLogger.error "Dynamic listeners using add_listener not supported \
+        in forked responder. Ignoring!"
+      end
+
+      @backend.reply_to(topic, opts, &handler)
+    end
+
+
     # Sends a response with _body_ and _code_
     # If +opts[:now]+ is true, the response is sent immediately,
     # else it is defered until the handler finishes executing
@@ -99,149 +128,140 @@ module Gilmour
       end
     end
 
-    def pub_relay(waiter)
-      Thread.new {
-        waiter.add 1
-        loop {
+    # This prohibits sending a response from a reply handler even after
+    # the request execution has finished. This is useful for sending
+    # a response from inside a closure if the handler has to make further
+    # gilmour requests. To send a response later, call respond with the
+    # option "now" as true.
+    def delay_response
+      @delayed_response = true
+    end
+
+    def delayed_response? #:nodoc:
+      @delayed_response
+    end
+
+    def command_relay(reader, waiter) #:nodoc:
+      waiter.add
+      pub_mutex = Mutex.new
+
+      Thread.new do
+        loop do
           begin
-            data = @read_publish_pipe.readline
-            destination, message = JSON.parse(data)
-            @backend.publish(message, destination)
+            data = reader.readline
+            pub_mutex.synchronize do
+              method, args = JSON.parse(data)
+              @backend.send(method.to_sym, *args)
+            end
           rescue EOFError
             waiter.done
+            break
           rescue Exception => e
             GLogger.debug e.message
             GLogger.debug e.backtrace
           end
-        }
-      }
+        end 
+      end 
     end
 
     # All logs in forked mode are relayed chr
-    def child_io_relay(io_reader, waiter, parent_logger)
-      Thread.new {
-        waiter.add 1
-        loop {
+    def logger_relay(read_logger_pipe, waiter, parent_logger) #:nodoc:
+      waiter.add 1
+      Thread.new do
+        loop do
           begin
-            data = io_reader.readline.chomp
-            if data.start_with?(LOG_PREFIX)
-              data.split(LOG_PREFIX).each do |msg|
-                unless msg.empty?
-                  msg_grp = msg.split(LOG_SEPERATOR, 2)
-                  if msg_grp.length > 1
-                    data = msg_grp[1]
-                    case msg_grp[0]
-                    when 'INFO'
-                      parent_logger.info data
-                    when 'UNKNOWN'
-                      parent_logger.unknown data
-                    when 'WARN'
-                      parent_logger.warn data
-                    when 'ERROR'
-                      parent_logger.error data
-                    when 'FATAL'
-                      parent_logger.fatal data
-                    else
-                      parent_logger.debug data
-                    end
-                  else
-                    parent_logger.debug msg
-                  end
-                end
-              end
-              next
-            end
-
-            parent_logger.debug data
+            data = read_logger_pipe.readline.chomp
+            logdata = JSON.parse(data)
+            meth = logdata['severity'].downcase.to_sym
+            parent_logger.send(meth, logdata['msg'])
+          rescue JSON::ParserError
+            parent_logger.info data
+            next
           rescue EOFError
             waiter.done
+            break
           rescue Exception => e
             GLogger.error e.message
             GLogger.error e.backtrace
           end
-        }
-      }
+        end #loop
+      end 
     end
 
     # Called by parent
-    # :nodoc:
-    def execute(handler)
-      if @multi_process
-        GLogger.debug "Executing #{@sender} in forked moode"
-
-        @read_pipe, @write_pipe = @pipe
-        @read_publish_pipe, @write_publish_pipe = @publish_pipe
-
-        io_reader, io_writer = IO.pipe
-
-        wg = Gilmour::Waiter.new
-        io_threads = []
-        io_threads << child_io_relay(io_reader, wg, @logger)
-        io_threads << pub_relay(wg)
+    def execute(handler) #:nodoc:
+      if !@multi_process
+        _execute(handler)
+        return
+      end
+      GLogger.debug "Executing #{@sender} in forked moode"
 
-        pid = Process.fork do
-          @backend.stop
-          EventMachine.stop_event_loop
+      # Create pipes for child communication
+      @read_pipe, @write_pipe = @response_pipe
+      @read_command_pipe, @write_command_pipe = @command_pipe
+      @read_logger_pipe, @write_logger_pipe = @logger_pipe = IO.pipe
 
-          #Close the parent channels in forked process
-          @read_pipe.close
-          @read_publish_pipe.close
-          io_reader.close unless io_reader.closed?
+      # setup relay threads
+      wg = Gilmour::Waiter.new
+      relay_threads = []
+      relay_threads << logger_relay(@read_logger_pipe, wg, @logger)
+      relay_threads << command_relay(@read_command_pipe, wg)
 
-          @response_sent = false
+      pid = Process.fork do
+        @backend.stop
+        EventMachine.stop_event_loop
 
-          @logger = fork_logger(io_writer)
-          _execute(handler)
-          io_writer.close
-        end
+        #Close the parent channels in forked process
+        @read_pipe.close
+        @read_command_pipe.close
+        @read_logger_pipe.close
 
-        # Cleanup the writers in Parent process.
-        io_writer.close
-        @write_pipe.close
-        @write_publish_pipe.close
+        @response_sent = false
 
-        begin
-          receive_data(@read_pipe.readline)
-        rescue EOFError => e
-          logger.debug e.message
-        end
+        # override the logger for the child
+        @logger = child_logger(@write_logger_pipe)
+        _execute(handler)
+        @write_logger_pipe.close
+      end
 
-        pid, status = Process.waitpid2(pid)
-        if !status
-          msg = "Child Process #{pid} crashed without status."
-          logger.error msg
-          # Set the multi-process mode as false, the child has died anyway.
-          @multi_process = false
-          write_response(@sender, msg, 500)
-        elsif status.exitstatus > 0
-          msg = "Child Process #{pid} exited with status #{status.exitstatus}"
-          logger.error msg
-          # Set the multi-process mode as false, the child has died anyway.
-          @multi_process = false
-          write_response(@sender, msg, 500)
-        end
+      # Cleanup the writers in Parent process.
+      @write_logger_pipe.close
+      @write_pipe.close
+      @write_command_pipe.close
 
-        @read_pipe.close
+      begin
+        receive_data(@read_pipe.readline)
+      rescue EOFError => e
+        logger.debug e.message
+      end
 
-        wg.wait do
-          io_threads.each { |th|
-            th.kill
-          }
-        end
+      pid, status = Process.waitpid2(pid)
+      if !status || status.exitstatus > 0
+        msg = if !status
+                "Child Process #{pid} crashed without status."
+              else
+                "Child Process #{pid} exited with status #{status.exitstatus}"
+              end
+        logger.error msg
+        # Set the multi-process mode as false, the child has died anyway.
+        @multi_process = false
+        write_response(@sender, msg, 500)
+      end
 
-        # Cleanup.
-        @read_publish_pipe.close
-        io_reader.close unless io_reader.closed?
+      @read_pipe.close
 
-      else
-        _execute(handler)
+      # relay cleanup.
+      wg.wait do
+        relay_threads.each { |th| th.kill }
       end
+      @read_command_pipe.close
+      @read_logger_pipe.close
     end
 
     # Publish all errors on gilmour.error
     # This may or may not have a listener based on the configuration
     # supplied at setup.
-    def emit_error(message, code = 500, extra = {})
+    def emit_error(message, code = 500, extra = {}) #:nodoc:
       opts = {
         topic: @request.topic,
         request_data: @request.body,
@@ -257,11 +277,11 @@ module Gilmour
     end
 
     # Called by child
-    # :nodoc:
-    def _execute(handler)
+    def _execute(handler) #:nodoc:
+      ret = nil
       begin
         Timeout.timeout(@timeout) do
-          instance_eval(&handler)
+          ret = instance_eval(&handler)
         end
       rescue Timeout::Error => e
         logger.error e.message
@@ -274,32 +294,58 @@ module Gilmour
         @response[:code] = 500
         @response[:data] = e.message
       end
-
+      @response[:code] ||= 200 if @respond && !delayed_response?
       send_response if @response[:code]
     end
 
-    # Publishes a message. See Backend::publish
-    def publish(message, destination, opts = {}, code=nil)
+    def call_parent_backend_method(method, *args) #:nodoc:
+      msg = JSON.generate([method, args])
+      @write_command_pipe.write(msg+"\n")
+      @write_command_pipe.flush
+    end
+
+    # Proxy to publish method. See Backend#publish
+    def publish(message, destination, opts = {}, code=nil, &blk)
       if @multi_process
         if block_given?
           GLogger.error "Publish callback not supported in forked responder. Ignoring!"
-#          raise Exception.new("Publish Callback is not supported in forked mode.")
         end
-
-        msg = JSON.generate([destination, message, code])
-        @write_publish_pipe.write(msg+"\n")
-        @write_publish_pipe.flush
+        call_parent_backend_method('publish', message, destination, opts, code)
+#        method = opts[:method] || 'publish'
+#        msg = JSON.generate([method, [message, destination, opts, code]])
+#        @write_command_pipe.write(msg+"\n")
+#        @write_command_pipe.flush
       elsif block_given?
-        blk = Proc.new
         @backend.publish(message, destination, opts, &blk)
       else
         @backend.publish(message, destination, opts)
       end
     end
 
+    # Proxy to request! method. See Backend#request!
+    def request!(message, destination, opts={}, &blk)
+      if @multi_process
+        if block_given?
+          GLogger.error "Publish callback not supported in forked responder. Ignoring!"
+        end
+        call_parent_backend_method('request!', message, destination, opts)
+      else
+        @backend.request!(message, destination, opts, &blk)
+      end
+    end
+
+    # Proxy to signal! method. See Backend#signal!
+    def signal!(message, destination, opts={})
+      if @multi_process
+        call_parent_backend_method('signal!', message, destination, opts)
+      else
+        @backend.signal!(message, destination, opts)
+      end
+    end
+
+
     # Called by child
-    # :nodoc:
-    def send_response
+    def send_response #:nodoc:
       return if @response_sent
       @response_sent = true
 

data/lib/gilmour/waiter.rb

@@ -14,7 +14,7 @@ module Gilmour
     def done
       synchronize do
         @count -= 1
-        if @count == 0
+        if @count <= 0
           @done = true
           @waiter_c.broadcast
         end
@@ -26,6 +26,10 @@ module Gilmour
     end
 
     def signal
+      if @count != 0
+        raise 'Cannot use signal alongside add/done'
+      end
+
       synchronize do
         @done = true
         @count = 0
@@ -34,31 +38,8 @@ module Gilmour
     end
 
     def wait(timeout=nil)
-      synchronize do
-        while !@done
-          @waiter_c.wait(@waiter_m, timeout)
-        end
-      end
+      synchronize { @waiter_c.wait(@waiter_m, timeout) unless @done }
       yield if block_given?
     end
   end
 end
-
-def test
-  wg = Gilmour::Waiter.new
-  wg.add 3
-
-  3.times do
-    Thread.new {
-      t = rand(10000) / 10000.0
-      sleep(t)
-      puts "done\n"
-      wg.done
-    }
-  end
-
-  wg.wait do
-    puts "All jobs done"
-  end
-
-end

data/test/spec/helpers/common.rb

@@ -1,26 +1,6 @@
+require '../lib/gilmour/waiter'
 
-class Waiter
-  def initialize
-    @done = false
-    @waiter_m = Mutex.new
-    @waiter_c = ConditionVariable.new
-  end
-
-  def synchronize(&blk)
-    @waiter_m.synchronize(&blk)
-  end
-
-  def signal
-    synchronize do
-      @done = true
-      @waiter_c.signal
-    end
-  end
-
-  def wait(timeout=nil)
-    synchronize { @waiter_c.wait(@waiter_m, timeout) unless @done }
-  end
-end
+Waiter = Gilmour::Waiter
 
 RSpec.configure do |config|
   config.expect_with :rspec do |c|

data/test/spec/helpers/connection.rb

@@ -25,12 +25,11 @@ def redis_wildcard_options
 end
 
 def redis_publish_async(options, message, key)
-  operation = proc do
-    redis = EM::Hiredis.connect
+  redis = EM::Hiredis.connect
+  EM.defer do
     payload, _ = Gilmour::Protocol.create_request(message)
     redis.publish(key, payload)
   end
-  EM.defer(operation)
 end
 
 def redis_send_and_recv(options, message, key)