logger_pipe 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fd276efaaeaec72d772ef2850226516e2fdbd75d
-  data.tar.gz: 3a8b2f21d9a5e920db4dd4ead277e89a78a0941d
+  metadata.gz: d79758d6c65671d213b290ca4e08150454226cfd
+  data.tar.gz: 94d6e1e1dce45bb19b42ba023516435fc15fa7c5
 SHA512:
-  metadata.gz: bf66b0f214bb5dbb5370cfec1e4339bffd2d9af0af26354e583e3f35b0732d60496b38eabb753a4b168112f87c1dfe8629fcf57a26898bd885c3d7e2396f3201
-  data.tar.gz: d28ec1066da06d0759b41b727e2ff31f684b815f27e74193143d248908ff0c8ceafaca9854af359d3d835f284eaafe1624d4c38bb34ae565a9dc6d3bb32f4106
+  metadata.gz: 5adaebe24771bb24c89a2513826a51e6b62426bf25d593e74c12250895c7c544a9899b1d0bef46e5ac2436be42a7e9a5d573151210a1302ed69bf611b6cdc7ba
+  data.tar.gz: df6264bee36af034611c03a4af30cc1af87b8ea956d99103ebcd8e36575d24263a65e8b38c786155b3056ea9c6957e01ad8eda66b7c8b67a39a787a9ac0e8438

data/.rspec

@@ -1,2 +1,2 @@
---format documentation
+--format Fuubar
 --color

data/README.md

@@ -1,4 +1,4 @@
-# LoggerPipe
+# LoggerPipe [![Build Status](https://travis-ci.org/groovenauts/logger_pipe.svg)](https://travis-ci.org/groovenauts/logger_pipe)
 
 TODO: Write a gem description
 

data/lib/logger_pipe.rb

@@ -3,7 +3,17 @@ require "logger_pipe/version"
 module LoggerPipe
   autoload :Runner, "logger_pipe/runner"
 
+  SOURCES = [:none, :stdout, :stderr, :both].freeze
+
   class << self
+    # run
+    # @param [Logger] logger
+    # @param [String] cmd Command to run on shell
+    # @param [Hash] options
+    # @option options [Integer] :timeout Seconds, default is nil.
+    # @option options [true|false] :dry_run If true given, command is not run actually
+    # @option options [Symbol] :returns Which output is used as return, one of :none, :stdout, :stderr, :both
+    # @option options [Symbol] :logging Which output is written to logger, one of :none, :stdout, :stderr, :both
     def run(logger, cmd, options = {})
       Runner.new(logger, cmd, options).execute
     end

data/lib/logger_pipe/runner.rb

@@ -16,11 +16,14 @@ module LoggerPipe
 
   class Runner
     attr_accessor :logger, :cmd, :timeout
+    attr_accessor :returns, :logging
 
     def initialize(logger, cmd, options = {})
       @logger, @cmd = logger, cmd
       @timeout = options[:timeout]
       @dry_run = options[:dry_run]
+      @returns = options[:returns] || :stdout # :none, :stdout, :stderr, :both
+      @logging = options[:logging] || :both   # :none, :stdout, :stderr, :both
     end
 
     def execute
@@ -28,35 +31,33 @@ module LoggerPipe
         logger.info("dry run: #{cmd}")
         return nil
       end
-      logger.info("executing: #{cmd}")
       @buf = []
       # systemをタイムアウトさせることはできないので、popenの戻り値を使っています。
       # see http://docs.ruby-lang.org/ja/2.0.0/class/Timeout.html
       @com, @pid = nil, nil
-      stderr_buffer do |stderr_fp|
-        timeout do
+      setup do |actual_cmd, log_enable|
+        logger.info("executing: #{actual_cmd}")
 
+        timeout do
           # popenにブロックを渡さないと$?がnilになってしまうので敢えてブロックで処理しています。
-          @com = IO.popen("#{cmd} 2> #{stderr_fp.path}") do |com|
+          @com = IO.popen(actual_cmd) do |com|
             @com = com
             @pid = com.pid
             while line = com.gets
               @buf << line
-              logger.debug(line.chomp)
+              logger.debug(line.chomp) if log_enable
             end
           end
           if $?.exitstatus == 0
-            logging_stderr(stderr_fp)
-            logger.info("\e[32mSUCCESS: %s\e[0m" % [cmd])
-            return @buf.join
+            logger.info("\e[32mSUCCESS: %s\e[0m" % [actual_cmd])
+            return (returns == :none) ? nil : @buf.join
           else
-            logging_stderr(stderr_fp)
-            msg = "\e[31mFAILURE: %s\e[0m" % [cmd]
+            msg = "\e[31mFAILURE: %s\e[0m" % [actual_cmd]
             logger.error(msg)
             raise Failure.new(msg, @buf)
           end
-
         end
+
       end
     end
 
@@ -88,19 +89,46 @@ module LoggerPipe
       end
     end
 
-    def stderr_buffer
-      Tempfile.open("logger_pipe.stderr.log") do |f|
-        f.close
-        return block_given? ? yield(f) : nil
+    def setup
+      raise ArgumentError, "Invalid option :returns #{returns.inspect}" unless SOURCES.include?(returns)
+      raise ArgumentError, "Invalid option :logging #{logging.inspect}" unless SOURCES.include?(logging)
+      if (returns == :both) && ([:stdout, :stderr].include?(logging))
+        raise ArgumentError, "Can' set logging: #{logging.inspect} with returns: #{returns.inspect}"
+      elsif (returns == :none) || (logging == :none) || (returns == logging)
+        actual_cmd =
+          case logging
+          when :none    then
+            case returns
+            when :none   then "#{cmd} 1>/dev/null 2>/dev/null"
+            when :stdout then "#{cmd} 2>/dev/null"
+            when :stderr then "#{cmd} 2>&1 1>/dev/null"
+            when :both   then "#{cmd} 2>&1"
+            end
+          when :stdout then "#{cmd} 2>/dev/null"
+          when :stderr then "#{cmd} 2>&1 1>/dev/null"
+          when :both   then "#{cmd} 2>&1"
+          end
+        return block_given? ? yield(actual_cmd, logging != :none) : nil
+      else
+        Tempfile.open("logger_pipe.stderr.log") do |f|
+          f.close
+          actual_cmd =
+            case returns
+            when :stdout then "#{cmd} 2>#{f.path}"
+            when :stderr then "#{cmd} 2>&1 1>#{f.path}"
+            end
+          begin
+            return block_given? ? yield(actual_cmd, logging == :both) : nil
+          ensure
+            logging_subfile(f)
+          end
+        end
       end
     end
 
-    def logging_stderr(f)
+    def logging_subfile(f)
       f.open
-      c = f.read
-      if !c.nil? && !c.empty?
-        logger.info("--- begin stderr ---\n#{c}\n--- end stderr ---")
-      end
+      logger.info("--- begin stderr ---\n%s\n--- end stderr ---" % f.read)
     end
   end
 

data/lib/logger_pipe/version.rb

@@ -1,3 +1,3 @@
 module LoggerPipe
-  VERSION = "0.3.0"
+  VERSION = "0.3.1"
 end

data/spec/logger_pipe_spec.rb

@@ -30,7 +30,7 @@ describe LoggerPipe do
       it "logging output" do
         LoggerPipe.run(logger, cmd)
         msg = buffer.string
-        expect(msg.lines.length).to eq 4
+        expect(msg.lines.length).to be >= 4
         expect(msg.lines[0]).to match /executing: #{Regexp.escape(cmd)}/
         expect(msg.lines[1]).to match /Foo: /
         expect(msg.lines[2]).to match /Bar: /
@@ -38,7 +38,7 @@ describe LoggerPipe do
       end
     end
 
-    context "stderr" do
+    context "stderr" do # default options are {return: :stdout, logging: :both}
       let(:cmd){ File.expand_path("../stderr_test.sh", __FILE__) }
       it "returns STDOUT on success" do
         res = LoggerPipe.run(logger, "#{cmd} 0")
@@ -56,6 +56,62 @@ describe LoggerPipe do
       end
     end
 
+    context ":returns and :logging" do
+      {
+        # [:returns, :logging] => [return of LoggerPipe.run, logging expectations]
+        [:none  , :none  ] => [nil              , {foo: false, bar: false, baz: false}], # OK
+        [:none  , :stdout] => [nil              , {foo: true , bar: false, baz: true }], # OK
+        [:none  , :stderr] => [nil              , {foo: false, bar: true , baz: false}], # OK
+        [:none  , :both  ] => [nil              , {foo: true , bar: true , baz: true }], # OK
+        [:stdout, :none  ] => ["foo\nbaz\n"     , {foo: false, bar: false, baz: false}], # OK
+        [:stdout, :stdout] => ["foo\nbaz\n"     , {foo: true , bar: false, baz: true }], # BINGO
+        [:stdout, :stderr] => ["foo\nbaz\n"     , {foo: false, bar: true , baz: false}], # NOT REALTIME
+        [:stdout, :both  ] => ["foo\nbaz\n"     , {foo: true , bar: true , baz: true }], # NOT REALTIME # DEFAULT
+        [:stderr, :none  ] => ["bar\n"          , {foo: false, bar: false, baz: false}], # OK
+        [:stderr, :stdout] => ["bar\n"          , {foo: true , bar: false, baz: true }], # NOT REALTIME
+        [:stderr, :stderr] => ["bar\n"          , {foo: false, bar: true , baz: false}], # BINGO
+        [:stderr, :both  ] => ["bar\n"          , {foo: true , bar: true , baz: true }], # NOT REALTIME
+        [:both  , :none  ] => ["foo\nbar\nbaz\n", {foo: false, bar: false, baz: false}], # OK
+        [:wrong , :none  ] => :invalid,
+        [:none  , :wrong ] => :invalid,
+        [:both  , :stdout] => :invalid,
+        [:both  , :stderr] => :invalid,
+        [:both  , :both  ] => ["foo\nbar\nbaz\n", {foo: true , bar: true , baz: true }], # BINGO
+      }.each do |options_values, expected|
+        options = {
+          returns: options_values.first,
+          logging: options_values.last,
+        }
+        context options do
+          let(:cmd){ File.expand_path("../stderr_test.sh", __FILE__) }
+          if expected == :invalid
+            it "raise invalid argument error" do
+              expect{ LoggerPipe.run(logger, "#{cmd} 0", options) }.to raise_error(ArgumentError)
+            end
+          else
+            it "returns STDOUT on success" do
+              res = LoggerPipe.run(logger, "#{cmd} 0", options)
+              expect(res).to eq expected.first
+              expected.last.each do |key, value|
+                m = value ? :to : :to_not
+                expect(buffer.string).send(m, match(/#{key}\n/))
+              end
+            end
+
+            it "buffer include stderr content on error" do
+              expect{
+                LoggerPipe.run(logger, "#{cmd} 1")
+              }.to raise_error(LoggerPipe::Failure)
+              # puts buffer.string
+              expect(buffer.string).to match /bar\n/
+            end
+          end
+        end
+
+      end
+    end
+
+
     context "dry_run: true" do
       let(:cmd){ "date +'Foo: %Y-%m-%dT%H:%M:%S'; sleep 1; date +'Bar: %Y-%m-%dT%H:%M:%S'" }
       it "returns nil" do
@@ -81,7 +137,7 @@ describe LoggerPipe do
       it "failure" do
         LoggerPipe.run(logger, cmd) rescue nil
         msg = buffer.string
-        expect(msg.lines.length).to eq 3
+        expect(msg.lines.length).to be >= 3
         expect(msg.lines[0]).to match /executing: #{Regexp.escape(cmd)}/
         expect(msg.lines[1]).to match /Foo: /
         expect(msg.lines[2]).to match /FAILURE: date \+'Foo: /

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: logger_pipe
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - akima