gilmour 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cb4068ed285f59f1c81d6466d2e28520971f467c
-  data.tar.gz: f1a1d0696b0fee3123231e0e7fa19daa50553904
+  metadata.gz: 762241aef84bf02c572d89ac9f22c16b710911dc
+  data.tar.gz: 50f90851b8bbe757576118d44480b4d102aa6d0e
 SHA512:
-  metadata.gz: 5a4c2e55ff101684ece9fdaed73c56303e21d2e310454b8454b4c00dacef3a5ac877c1b01068948dbf82fcf40728b0b1ee6915c458ed687e7db0c19aad96c0af
-  data.tar.gz: df8085937a9af0f214683dd20b00d484ccd5da65d501c823569c58036c59377d7bba1c123e3329aacdd3f2f41f7ac583b3ad38d63f29bcba36512d0d7f257d81
+  metadata.gz: d91f45f9377ff883ff8c371c21212e2702323649c4d45d819bf405bbb570aa3ccd0dff4c401a85d5d59e6a745b2a2398f456947bdc83183c51dc99a0ed31e573
+  data.tar.gz: 8202e63ba3940829ccac7a89aeba02336f0b2f6b18001c73d3549da496a4576ddb54d01b6ded31472bc2af8891bab5d24b8512bed8dda696065b35c63a1a2b7c

data/gilmour.gemspec

@@ -3,24 +3,24 @@ $:.push File.expand_path("../lib", __FILE__)
 require "./version"
 
 Gem::Specification.new do |s|
-	s.name        = "gilmour"
-	s.version     = Gilmour::VERSION
-	s.platform    = Gem::Platform::RUBY
-	s.authors     = ["Aditya Godbole"]
-	s.email       = ["code.aa@gdbl.me"]
-	s.homepage    = ""
-	s.summary     = %q{A Sinatra like DSL for implementing AMQP services}
-	s.description = %q{This gem provides a Sinatra like DSL and a simple protocol to enable writing services that communicate over AMQP}
+  s.name        = "gilmour"
+  s.version     = Gilmour::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Aditya Godbole", "Piyush Verma"]
+  s.email       = ["code.aa@gdbl.me", "piyush@piyushverma.net"]
+  s.homepage    = ""
+  s.summary     = %q{A Sinatra like DSL for implementing AMQP services}
+  s.description = %q{This gem provides a Sinatra like DSL and a simple protocol to enable writing services that communicate over AMQP}
 
-	s.add_development_dependency "rspec"
-	s.add_development_dependency "rspec-given"
-	s.add_dependency "mash"
-	s.add_dependency "redis"
-	s.add_dependency "gilmour-em-hiredis"
-	s.add_dependency "amqp"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "rspec-given"
+  s.add_dependency "mash"
+  s.add_dependency "redis"
+  s.add_dependency "gilmour-em-hiredis"
+  s.add_dependency "amqp"
 
-	s.files         = `git ls-files`.split("\n")
-	s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-	s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-	s.require_paths = ["lib"]
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
 end

data/lib/gilmour/responder.rb

@@ -2,6 +2,8 @@
 
 require 'json'
 require 'logger'
+require_relative './stdhijack'
+require_relative './waiter'
 
 # Top level module
 module Gilmour
@@ -20,9 +22,23 @@ module Gilmour
   end
 
   class Responder
+    CAPTURE_STDOUT = false
+    LOG_SEPERATOR = '%%'
+    LOG_PREFIX = "#{LOG_SEPERATOR}gilmour#{LOG_SEPERATOR}"
+
     attr_reader :logger
     attr_reader :request
 
+    def fork_logger
+      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|
+        "#{LOG_PREFIX}#{severity}#{LOG_SEPERATOR}#{msg}"
+      end
+      logger
+    end
+
     def make_logger
       logger = Logger.new(STDERR)
       original_formatter = Logger::Formatter.new
@@ -82,53 +98,129 @@ module Gilmour
       end
     end
 
+    def pub_relay(waiter)
+      Thread.new {
+        waiter.add 1
+        loop {
+          begin
+            data = @read_publish_pipe.readline
+            destination, message = JSON.parse(data)
+            @backend.publish(message, destination)
+          rescue EOFError
+            waiter.done
+          rescue Exception => e
+            GLogger.debug e.message
+            GLogger.debug e.backtrace
+          end
+        }
+      }
+    end
+
+    def io_readers(parent_io, waiter)
+      io_threads = []
+
+      parent_io.each do |reader|
+        io_threads << Thread.new {
+          waiter.add 1
+          loop {
+            begin
+              data = reader.readline.chomp
+              if data.empty?
+                next
+              end
+
+              if data.start_with?(LOG_PREFIX)
+                data.split(LOG_PREFIX).each do |msg|
+                  msg_grp = msg.split(LOG_SEPERATOR, 2)
+
+                  if msg_grp.length > 1
+                    data = msg_grp[1]
+                    case msg_grp[0]
+                    when 'INFO'
+                      logger.info data
+                    when 'UNKNOWN'
+                      logger.unknown data
+                    when 'WARN'
+                      logger.warn data
+                    when 'ERROR'
+                      logger.error data
+                    when 'FATAL'
+                      logger.fatal data
+                    else
+                      logger.debug data
+                    end
+                  else
+                    logger.debug msg
+                  end
+
+                end
+                next
+              end
+
+              logger.debug data
+            rescue EOFError
+              waiter.done
+            rescue Exception => e
+              GLogger.error e.message
+              GLogger.error e.backtrace
+            end
+          }
+        }
+      end
+
+      io_threads
+    end
+
     # Called by parent
     # :nodoc:
     def execute(handler)
       if @multi_process
         GLogger.debug "Executing #{@sender} in forked moode"
-        @read_pipe = @pipe[0]
-        @write_pipe = @pipe[1]
 
-        @read_publish_pipe = @publish_pipe[0]
-        @write_publish_pipe = @publish_pipe[1]
+        @read_pipe, @write_pipe = @pipe
+        @read_publish_pipe, @write_publish_pipe = @publish_pipe
+
+        out_r, out_w = IO.pipe
+        parent_io = [out_r]
+        child_io = [out_w]
+
+        if CAPTURE_STDOUT == true
+          err_r, err_w = IO.pipe
+          child_io << err_w
+          parent_io << err_r
+        end
 
         pid = Process.fork do
           @backend.stop
           EventMachine.stop_event_loop
+
+          #Close the parent channels in forked process
           @read_pipe.close
           @read_publish_pipe.close
+          parent_io.each{|io| io.close}
+
           @response_sent = false
-          _execute(handler)
+          @logger = fork_logger
+
+          capture_output(child_io, CAPTURE_STDOUT) {
+            _execute(handler)
+          }
         end
 
+        # Cleanup the writers in Parent process.
+        child_io.each {|io| io.close }
+
         @write_pipe.close
         @write_publish_pipe.close
 
-        pub_mutex = Mutex.new
-
-        pub_reader = Thread.new {
-          loop {
-            begin
-              data = @read_publish_pipe.readline
-              pub_mutex.synchronize do
-                destination, message = JSON.parse(data)
-                @backend.publish(message, destination)
-              end
-            rescue EOFError
-              # awkward blank rescue block
-            rescue Exception => e
-              GLogger.debug e.message
-              GLogger.debug e.backtrace
-            end
-          }
-        }
+        wg = Gilmour::Waiter.new
+        io_threads = io_readers(parent_io, wg)
+        io_threads << pub_relay(wg)
 
         begin
           receive_data(@read_pipe.readline)
         rescue EOFError => e
           logger.debug e.message
-          logger.debug "EOFError caught in responder.rb, because of nil response"
         end
 
         pid, status = Process.waitpid2(pid)
@@ -146,12 +238,18 @@ module Gilmour
           write_response(@sender, msg, 500)
         end
 
-        pub_mutex.synchronize do
-          pub_reader.kill
+        @read_pipe.close
+
+        wg.wait do
+          io_threads.each { |th|
+            th.kill
+          }
         end
 
-        @read_pipe.close
+        # Cleanup.
         @read_publish_pipe.close
+        parent_io.each{|io| io.close unless io.closed?}
+
       else
         _execute(handler)
       end
@@ -162,7 +260,7 @@ module Gilmour
     # supplied at setup.
     def emit_error(message, code = 500, extra = {})
       opts = {
-        topic: @request.topic, 
+        topic: @request.topic,
         request_data: @request.body,
         userdata: JSON.generate(extra || {}),
         sender: @sender,

data/lib/gilmour/stdhijack.rb

@@ -0,0 +1,49 @@
+# StringIO also do as IO, but IO#reopen fails.
+# The problem is that a StringIO cannot exist in the O/S's file descriptor
+# table. STDERR.reopen(...) at the low level does a dup() or dup2() to
+# copy one file descriptor to another.
+#
+# I have two options:
+#
+# (1) $stderr = StringIO.new
+# Then any program which writes to $stderr will be fine. But anything
+# which writes to STDERR will still go to file descriptor 2.
+#
+# (2) reopen STDERR with something which exists in the O/S file descriptor
+# table: e.g. a file or a pipe.
+#
+# I canot use a file, hence a Pipe.
+
+def capture_output(pipes, capture_stdout=false)
+  streams = []
+
+  if capture_stdout == true
+    streams << $stdout
+  end
+
+  streams << $stderr
+
+  # Save the streams to be reassigned later.
+  # Actually it doesn't matter because the child process would be killed
+  # anyway after the work is done.
+  saved = streams.each do |stream|
+    stream.dup
+  end
+
+  begin
+    streams.each_with_index do |stream, ix|
+      # Probably I should not use IX, otherwise stdout and stderr can arrive
+      # out of order, which they should?
+      # If I reopen both of them on the same PIPE, they are guaranteed to
+      # arrive in order.
+      stream.reopen(pipes[ix])
+    end
+    yield
+  ensure
+    # This is sort of meaningless, just makes sense aesthetically.
+    # To return what was borrowed.
+    streams.each_with_index do |stream, i|
+      stream.reopen(saved[i])
+    end
+  end
+end

data/lib/gilmour/waiter.rb

@@ -1,11 +1,25 @@
 module Gilmour
   class Waiter
     def initialize
+      @count = 0
       @done = false
       @waiter_m = Mutex.new
       @waiter_c = ConditionVariable.new
     end
 
+    def add n = 1
+      synchronize { @count += n }
+    end
+
+    def done
+      synchronize do
+        @count -= n
+        if @count == 0
+          signal
+        end
+      end
+    end
+
     def synchronize(&blk)
       @waiter_m.synchronize(&blk)
     end
@@ -13,12 +27,33 @@ module Gilmour
     def signal
       synchronize do
         @done = true
+        @count = 0
         @waiter_c.signal
       end
     end
 
     def wait(timeout=nil)
       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/version.rb

@@ -1,3 +1,3 @@
 module Gilmour
-    VERSION = '0.3.0'
+    VERSION = '0.3.1'
 end

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: gilmour
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Aditya Godbole
+- Piyush Verma
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-10 00:00:00.000000000 Z
+date: 2015-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -98,6 +99,7 @@ description: This gem provides a Sinatra like DSL and a simple protocol to enabl
   writing services that communicate over AMQP
 email:
 - code.aa@gdbl.me
+- piyush@piyushverma.net
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -117,6 +119,7 @@ files:
 - lib/gilmour/base.rb
 - lib/gilmour/protocol.rb
 - lib/gilmour/responder.rb
+- lib/gilmour/stdhijack.rb
 - lib/gilmour/waiter.rb
 - test/spec/helpers/common.rb
 - test/spec/helpers/connection.rb