gilmour 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b164c237e9423f1bbcc3e91cf3dc94c376c7163e
-  data.tar.gz: 87aec87330f766c0e5428fa301637e077dc61a41
+  metadata.gz: 7927c5fb1c94d36f7ae85c605d16b3e715cc215a
+  data.tar.gz: b57d2ca7464355623376c35faa04e2e0adbc133b
 SHA512:
-  metadata.gz: 9227f1a16c983556caaa99b9a712e3641d0f208f517eab8eba0fb3001f543146c57284ea8b1cda44982099ad69a40b54ddaa31069384b5c165a5ec5292c778ff
-  data.tar.gz: ec09fe7036f7829e1d5478b6f8ffcdd97216a09b94822b5c29bb5803af4f5f23b477f8bfea1d19da9f9ac5ee4b83dbe1478ea0373df2041a94c5c406e368029f
+  metadata.gz: 088587c3aea578730a2926698cd952d76e101abd6e1c5e99e57459116407bc5cc27d68d91b9ceaec64fb0412718da5ad4e620859b81bd5f638af102faa82ad29
+  data.tar.gz: 80fe912c98305251b4871be44e10f4c8ee9551e185cfb7c4c31b9bff86289cbdbae905a03309754bff0f53a58a22d3842aa280a7cb4fc2bca25a59e4ffd9440b

data/examples/fork_log_server.rb

@@ -0,0 +1,97 @@
+# encoding: utf-8
+require_relative '../lib/gilmour'
+
+class EventServer
+  include Gilmour::Base
+
+  def initialize
+    backend = 'redis'
+    enable_backend(backend, { })
+    registered_subscribers.each do |sub|
+      sub.backend = backend
+    end
+    $stderr.puts "Starting server. To see messaging in action run clients."
+    start(true)
+  end
+end
+
+class EchoSubscriber < EventServer
+  class << self
+    def capture_output(pipe)
+      streams = [$stdout, $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.collect { |stream| stream.dup }
+
+      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(pipe)
+          #stream.sync = true
+        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
+        pipe.close unless pipe.closed?
+      end
+    end
+
+    def ds_respond(topic, opts={}, &blk)
+      options = { exclusive: true, fork: true }.merge(opts)
+      listen_to topic, options do
+        logger.error "Captuting output before execution"
+
+        waiter = Gilmour::Waiter.new
+        waiter.add 1
+        read_pipe, write_pipe = IO.pipe
+
+        th = Thread.new {
+          loop {
+            begin
+              result = read_pipe.readline.chomp
+              logger.debug result
+            rescue EOFError
+              waiter.done
+            rescue Exception => e
+              logger.error "Error: #{e.message}"
+              logger.error "Traceback: #{e.backtrace}"
+            end
+          }
+        }
+
+        EchoSubscriber::capture_output(write_pipe) do
+          instance_eval(&blk)
+        end
+
+        waiter.wait do
+          th.kill
+        end
+
+      end
+    end
+  end
+
+  # Passing second parameter as true makes only one instance of this handler handle a request
+  EchoSubscriber::ds_respond 'echo.*' do
+    if request.body == 'Palmolive'
+      respond nil
+    else
+      logger.error "logger: #{request.body}"
+      $stderr.puts "stderr.puts: #{request.body}"
+      puts "stdout.puts #{request.body}"
+      respond "#{request.topic}"
+    end
+  end
+
+end
+
+EventServer.new

data/lib/gilmour/backends/redis.rb

@@ -42,9 +42,6 @@ module Gilmour
       @report_errors = opts["broadcast_errors"] || opts[:broadcast_errors]
       @report_errors = true if @report_errors != false
 
-      @capture_stdout = opts["capture_stdout"] || opts[:capture_stdout]
-      @capture_stdout = false if @capture_stdout != true
-
       @ident = generate_ident
     end
 
@@ -56,10 +53,6 @@ module Gilmour
       "#{Socket.gethostname}-pid-#{Process.pid}-uuid-#{SecureRandom.uuid}"
     end
 
-    def capture_stdout?
-      @capture_stdout
-    end
-
     def report_health?
       @report_health
     end

data/lib/gilmour/responder.rb

@@ -2,7 +2,6 @@
 
 require 'json'
 require 'logger'
-require_relative './stdhijack'
 require_relative './waiter'
 
 # Top level module
@@ -28,12 +27,16 @@ module Gilmour
     attr_reader :logger
     attr_reader :request
 
-    def fork_logger
+    def fork_logger(io_writer)
       logger = Logger.new(STDERR)
       loglevel =  ENV["LOG_LEVEL"] ? ENV["LOG_LEVEL"].to_sym : :warn
       logger.level = Gilmour::LoggerLevels[loglevel] || Logger::WARN
+      logger.datetime_format = "%Y-%m-%d %H:%M:%S"
       logger.formatter = proc do |severity, datetime, progname, msg|
-        "#{LOG_PREFIX}#{severity}#{LOG_SEPERATOR}#{msg}"
+        data = "#{LOG_PREFIX}#{severity}#{LOG_SEPERATOR}#{msg}"
+        io_writer.write(data+"\n")
+        io_writer.flush
+        nil
       end
       logger
     end
@@ -43,6 +46,7 @@ module Gilmour
       original_formatter = Logger::Formatter.new
       loglevel =  ENV["LOG_LEVEL"] ? ENV["LOG_LEVEL"].to_sym : :warn
       logger.level = Gilmour::LoggerLevels[loglevel] || Logger::WARN
+      logger.datetime_format = "%Y-%m-%d %H:%M:%S"
       logger.formatter = proc do |severity, datetime, progname, msg|
         original_formatter.call(severity, datetime, @sender, msg)
       end
@@ -59,7 +63,6 @@ module Gilmour
       @pipe = IO.pipe
       @publish_pipe = IO.pipe
       @logger = make_logger()
-      @capture_stdout = @backend.capture_stdout? || false
     end
 
     def receive_data(data)
@@ -116,59 +119,50 @@ module Gilmour
       }
     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|
+    # All logs in forked mode are relayed chr
+    def child_io_relay(io_reader, waiter, parent_logger)
+      Thread.new {
+        waiter.add 1
+        loop {
+          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'
-                      logger.info data
+                      parent_logger.info data
                     when 'UNKNOWN'
-                      logger.unknown data
+                      parent_logger.unknown data
                     when 'WARN'
-                      logger.warn data
+                      parent_logger.warn data
                     when 'ERROR'
-                      logger.error data
+                      parent_logger.error data
                     when 'FATAL'
-                      logger.fatal data
+                      parent_logger.fatal data
                     else
-                      logger.debug data
+                      parent_logger.debug data
                     end
                   else
-                    logger.debug msg
+                    parent_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
+              next
             end
-          }
-        }
-      end
 
-      io_threads
+            parent_logger.debug data
+          rescue EOFError
+            waiter.done
+          rescue Exception => e
+            GLogger.error e.message
+            GLogger.error e.backtrace
+          end
+        }
+      }
     end
 
     # Called by parent
@@ -180,15 +174,12 @@ module Gilmour
         @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]
+        io_reader, io_writer = IO.pipe
 
-        if @capture_stdout == true
-          err_r, err_w = IO.pipe
-          child_io << err_w
-          parent_io << err_r
-        end
+        wg = Gilmour::Waiter.new
+        io_threads = []
+        io_threads << child_io_relay(io_reader, wg, @logger)
+        io_threads << pub_relay(wg)
 
         pid = Process.fork do
           @backend.stop
@@ -197,26 +188,20 @@ module Gilmour
           #Close the parent channels in forked process
           @read_pipe.close
           @read_publish_pipe.close
-          parent_io.each{|io| io.close}
+          io_reader.close unless io_reader.closed?
 
           @response_sent = false
-          @logger = fork_logger
 
-          capture_output(child_io, @capture_stdout) {
-            _execute(handler)
-          }
+          @logger = fork_logger(io_writer)
+          _execute(handler)
+          io_writer.close
         end
 
         # Cleanup the writers in Parent process.
-        child_io.each {|io| io.close }
-
+        io_writer.close
         @write_pipe.close
         @write_publish_pipe.close
 
-        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
@@ -248,7 +233,7 @@ module Gilmour
 
         # Cleanup.
         @read_publish_pipe.close
-        parent_io.each{|io| io.close unless io.closed?}
+        io_reader.close unless io_reader.closed?
 
       else
         _execute(handler)

data/lib/gilmour/waiter.rb

@@ -13,9 +13,10 @@ module Gilmour
 
     def done
       synchronize do
-        @count -= n
+        @count -= 1
         if @count == 0
-          signal
+          @done = true
+          @waiter_c.broadcast
         end
       end
     end
@@ -33,7 +34,11 @@ module Gilmour
     end
 
     def wait(timeout=nil)
-      synchronize { @waiter_c.wait(@waiter_m, timeout) unless @done }
+      synchronize do
+        while !@done
+          @waiter_c.wait(@waiter_m, timeout)
+        end
+      end
       yield if block_given?
     end
   end

data/version.rb

@@ -1,3 +1,3 @@
 module Gilmour
-    VERSION = '0.3.2'
+    VERSION = '0.3.3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gilmour
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Aditya Godbole
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-29 00:00:00.000000000 Z
+date: 2015-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -110,6 +110,7 @@ files:
 - LICENSE
 - README.md
 - examples/echoclient.rb
+- examples/fork_log_server.rb
 - examples/server.rb
 - examples/thread_example.rb
 - gilmour.gemspec
@@ -119,7 +120,6 @@ 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

data/lib/gilmour/stdhijack.rb

@@ -1,49 +0,0 @@
-# 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