aggkit 0.3.8.9036 → 0.4.0.9098

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0f6196bc283eb4ae7ebc271822bee2b859e9dfbe
-  data.tar.gz: d652c25bc8c40fbb203bb6f0339bd375113982b9
+  metadata.gz: d61521bee578abba7b80c9ad0182aae2483d42ca
+  data.tar.gz: a55d378ef1f3a44cd9a562cb9857aab3d7ab318f
 SHA512:
-  metadata.gz: d9959a89a2ece7d74008f8c5b3ebf64f170b4cac72ee4f9b9ee4a5c9b8c29c78085898451accf280472dbfa1efaa91e4753b7f32ed0dcdb2e7399e7211460851
-  data.tar.gz: fd1a2fa29e6bff027cdd41721477d71d0ae39ba2423175bb12b7059db74d650e431896fb85d13cdd840bb45eec013f185dbfbe3d20676543745881a0674754f1
+  metadata.gz: 970126d8a53f24b3a75f3317d4bd3db962540cae8eedcaa74ba33e0fa9d726837e0d975484c9dc9166566027527a25de31197bdd761f521ea317e277c2957bfb
+  data.tar.gz: c3082b9794e11ded61f6a67ef2826dfa3626533f596a5dd3bf464527774c973f23cf4c82b81ad20c8bd81d664fe835fb6915d2d1c3f737ba15f9322499d5d124

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    aggkit (0.3.8.9036)
+    aggkit (0.4.0.9098)
       diplomat
       dotenv
       json
@@ -12,9 +12,8 @@ GEM
   specs:
     awesome_print (1.8.0)
     diff-lcs (1.3)
-    diplomat (2.0.2)
+    diplomat (2.0.5)
       faraday (~> 0.9)
-      json
     dotenv (2.7.1)
     faraday (0.15.4)
       multipart-post (>= 1.2, < 3)

data/bin/aggconsul

@@ -13,7 +13,7 @@ if ENV['CONSUL_HTTP_ADDR'].to_s.empty?
 end
 
 @opts = {
-  consul:  ENV['CONSUL_HTTP_ADDR']
+  consul: ENV['CONSUL_HTTP_ADDR']
 }
 
 @opts[:exec] = (begin
@@ -26,12 +26,12 @@ parser = OptionParser.new do |o|
   o.banner = 'Usage: consul.rb [options] -- exec'
 
   o.on('--consul url', 'Set up a custom Consul URL') do |consul|
-    if consul.to_s['http']
-      ENV['CONSUL_HTTP_ADDR'] = consul.to_s
+    ENV['CONSUL_HTTP_ADDR'] = if consul.to_s['http']
+      consul.to_s
     else
-      ENV['CONSUL_HTTP_ADDR'] = "http://#{consul.to_s}:8500"
+      "http://#{consul}:8500"
     end
-    
+
     @opts[:consul] = ENV['CONSUL_HTTP_ADDR']
   end
 

data/bin/aggstart

@@ -31,12 +31,12 @@ parser = Aggkit::OptionParser.new do |o|
   end
 
   o.on("--consul=#{@opts[:consul]}", 'Set consul http address. CONSUL_HTTP_ADDR env can be used instead') do |consul|
-    if consul.to_s['http']
-      ENV['CONSUL_HTTP_ADDR'] = consul.to_s
+    ENV['CONSUL_HTTP_ADDR'] = if consul.to_s['http']
+      consul.to_s
     else
-      ENV['CONSUL_HTTP_ADDR'] = "http://#{consul.to_s}:8500"
+      "http://#{consul}:8500"
     end
-    
+
     @opts[:consul] = ENV['CONSUL_HTTP_ADDR']
   end
 

data/bin/aggterm

@@ -12,7 +12,7 @@ STDERR.sync = true
 }
 
 def log(msg)
-  puts "[terminator]: #{msg}"
+  puts "[terminator:#{::Process.pid}][#{Time.now.strftime('%H:%M:%S.%L')}]: #{msg}"
 end
 
 log "started: #{ARGV.inspect}"
@@ -40,6 +40,10 @@ parser = OptionParser.new do |o|
   o.on('--kill', 'SIGKILL self') do
     @opts[:kill] = true
   end
+
+  o.on('--fork NUM', 'fork NUM suprocesses and wait') do |num|
+    @opts[:fork] = Integer(num.to_s)
+  end
 end
 parser.parse!
 
@@ -53,6 +57,29 @@ parser.parse!
   end
 end
 
+if @opts[:fork]
+  log 'forking...'
+  pids = @opts[:fork].times.map do |i|
+    fork do
+      exec 'echo', "#{i} forked"
+    end
+  end
+  sleep 1
+  pids.each do |pid|
+    pid, status = ::Process.wait2(pid, Process::WNOHANG)
+
+    if status.nil?
+      log 'child already collected'
+      exit 1
+    end
+
+    unless status.success?
+      log 'child crashed'
+      exit 2
+    end
+  end
+end
+
 log 'sleep...'
 sleep @opts[:sleep]
 
@@ -67,6 +94,7 @@ if @opts[:term]
   ::Process.kill('TERM', $PROCESS_ID)
 end
 
+
 log "normal exit with: #{@opts[:code]}"
 exit @opts[:code]
 

data/bin/aggwrap

@@ -6,8 +6,10 @@ require 'aggkit'
 require 'net/http'
 
 module Diplomat
+
   # Methods for interacting with the Consul check API endpoint
   class Check < Diplomat::RestClient
+
     # Update a TTL check
     # @param check_id [String] the unique id of the check
     # @param status [String] status of the check. Valid values are "passing", "warning", and "critical"
@@ -44,7 +46,9 @@ module Diplomat
     def fail(check_id, output = nil)
       update_ttl(check_id, 'critical', output)
     end
+
   end
+
 end
 
 
@@ -61,7 +65,7 @@ end
 @opts = {
   service: ENV['AGGREDATOR_SERVICE'],
   id:      SecureRandom.hex(8),
-  consul:  ENV['CONSUL_HTTP_ADDR'],
+  consul:  ENV['CONSUL_HTTP_ADDR']
 }
 
 @opts[:exec] = (begin
@@ -83,12 +87,12 @@ parser = Aggkit::OptionParser.new do |o|
   end
 
   o.on("--consul=#{@opts[:consul]}", 'Set consul host. CONSUL_HOST env used when missed') do |consul|
-    if consul.to_s['http']
-      ENV['CONSUL_HTTP_ADDR'] = consul.to_s
+    ENV['CONSUL_HTTP_ADDR'] = if consul.to_s['http']
+      consul.to_s
     else
-      ENV['CONSUL_HTTP_ADDR'] = "http://#{consul.to_s}:8500"
+      "http://#{consul}:8500"
     end
-    
+
     @opts[:consul] = ENV['CONSUL_HTTP_ADDR']
   end
 
@@ -114,7 +118,7 @@ die 'service name must be provided' if @opts[:service].to_s.empty?
 
 die 'script must be provided' if @opts[:exec].empty?
 
-    
+
 Diplomat.configure do |config|
   config.url = @opts[:consul]
 end

data/lib/aggkit.rb

@@ -5,10 +5,11 @@ require 'dotenv'
 
 require 'aggkit/version'
 require 'aggkit/option_parser'
+require 'aggkit/childprocess'
 require 'aggkit/watcher'
 require 'aggkit/runner'
 require 'aggkit/env'
-require 'aggkit/childprocess'
+
 
 module Aggkit
 

data/lib/aggkit/childprocess/abstract_process.rb

@@ -5,6 +5,8 @@ module ChildProcess
 
     attr_reader :exit_code
 
+    attr_reader :status
+
     #
     # Set this to true if you do not care about when or if the process quits.
     #

data/lib/aggkit/childprocess/unix/process.rb

@@ -74,6 +74,7 @@ module ChildProcess
       end
 
       def set_exit_code(status)
+        @status = status
         @exit_code = status.exitstatus || status.termsig
       end
 

data/lib/aggkit/runner.rb

@@ -47,14 +47,25 @@ module Aggkit
 
     def execute(cmd)
       puts "Executing: #{cmd}"
-      output = `#{cmd}`
+      io = IO.popen(cmd)
+      output = io.read
+      begin
+        io.close
+      rescue StandardError
+        nil
+      end
       @last_result = $?
       output
     end
 
     def execute!(cmd, error = nil)
       output = execute(cmd)
-      ($? || @last_result).success? || die(error || "Can't execute: #{cmd}")
+      if @last_result
+        @last_result.success? || die(error || "Can't execute: #{cmd}")
+      else
+        die("Already collected: #{cmd}")
+      end
+
       output
     end
 

data/lib/aggkit/version.rb

@@ -1,6 +1,6 @@
 module Aggkit
 
-  VERSION = '0.3.8'.freeze
+  VERSION = '0.4.0'.freeze
 
 end
 

data/lib/aggkit/watcher.rb

@@ -5,235 +5,207 @@ module Aggkit
 
   class Watcher
 
+    require 'aggkit/watcher/process_handler'
+
+    attr_accessor :iolock
+
+    EXIT_SIGNALS = %w[EXIT QUIT].freeze
+    TERM_SIGNALS = %w[INT TERM].freeze
+
+    class Pipe
+
+      def initialize
+        @read, @write = IO.pipe
+      end
+
+      def puts(str)
+        @write.puts str.to_s
+      end
+
+      def gets
+        @read.gets.strip.to_sym
+      end
+
+    end
 
     def initialize
-      @lock = Mutex.new
+      @iolock = Mutex.new
+      @pipe = Pipe.new
 
       @procs = []
       @code = 0
       @crashed = false
-      @threads = []
       @who = nil
-      @stopping = false
-      end
+    end
 
-    def stop_all
-      @stopping = true
+    def add(*cmd)
+      log "Starting #{cmd}..."
+      @procs.push ProcessHandler.new(self, *cmd)
+      log "  * PID: #{@procs.last.pid}"
+      @procs.last
+    end
 
-      terminating = @procs.reject do |meta|
-        meta[:handled] || meta[:process].exited?
-      end
+    def log(msg)
+      @iolock.synchronize{ STDOUT.puts("[watcher][#{Time.now.strftime('%H:%M:%S.%L')}]: #{msg}") }
+    end
 
-      terminating.each do |meta|
-        begin
-          meta[:stdin].close
-        rescue StandardError
-          nil
-        end
-        if meta[:termcmd].is_a? String
-          log "Terminating by #{meta[:termcmd].gsub('%PID%', meta[:process].pid.to_s)}..."
-          output = `#{meta[:termcmd].gsub('%PID%', meta[:process].pid.to_s)}`
-          if $?.success?
-            log "ok: #{output}"
-          else
-            log "Error: #{output}"
-            ::Process.kill 'TERM', meta[:process].pid
-          end
-        else
-          ::Process.kill 'TERM', meta[:process].pid
-        end
-      end
+    def error(msg)
+      @iolock.synchronize{ STDERR.puts("[watcher][#{Time.now.strftime('%H:%M:%S.%L')}]: Error: #{msg}") }
+    end
 
-      terminating.each do |meta|
-        begin
-          meta[:process].poll_for_exit(5)
-        rescue ChildProcess::TimeoutError
-          meta[:process].stop(1)
-          meta[:stdout].close
-          meta[:stderr].close
-        end
+    def set_crash_report(pr)
+      unless @crashed
+        @crashed  = true
+        @code     = pr.exit_code
+        @who      = pr.command
       end
+    end
 
-      unless @crashed
-        meta = @procs.detect do |meta|
-          meta[:process].crashed?
-        end
+    def quit!
+      @code = [@code || 0, 1].max if @crashed
+      exit!(@code || 0)
+    end
 
-        if meta
-          @crashed = true
-          @code = meta[:process].exit_code
-          @who = meta[:cmd]
-        end
-      end
+    def terminate_all
+      raise 'Double termination occured!' if $terminating
 
-      @procs.each do |meta|
-        begin
-        meta[:stdout].close
-      rescue StandardError
-        nil
-      end
-        begin
-        meta[:stderr].close
-      rescue StandardError
-        nil
-      end
-      end
+      $terminating = true
+      running = @procs.reject(&:handled?)
 
-      Thread.new do
-        sleep 2
-        @threads.each(&:terminate)
-      end
+      running.each do |pr|
+        begin
+          pr.stdin.close
+        rescue StandardError
+          nil
         end
-
-    def add(*cmd)
-      options = cmd.last
-      if options.is_a? Hash
-        cmd.pop
-      else
-        options = {}
+        pr.terminate
       end
 
-      cmd = cmd.flatten.map{|c| c.to_s.strip }.reject(&:empty?)
-      process = ChildProcess.build(*cmd)
+      running.each do |pr|
+        pr.stop
+        collect_managed(pr)
+      end
+    end
 
-      rerr, werr = IO.pipe
-      rout, wout = IO.pipe
+    def exec
+      install_signal_handlers(@pipe)
 
-      process.io.stdout = wout
-      process.io.stderr = werr
-      process.duplex = true
+      begin
+        yield(self)
+      rescue StandardError => e
+        @crashed = true
+        @code = 1
+        error e.inspect
+        error e.backtrace.last(20).join("\n")
+        log 'Try exits gracefully..'
+        terminate_all
+        exit!(@code)
+      end
 
-      meta = {
-        cmd:     cmd,
-        process: process,
-        stdout:  rout,
-        stderr:  rerr,
-        stdin:   process.io.stdin,
-        termcmd: options[:termcmd]
-      }
+      loop_childs
+      quit! if @procs.all?(&:handled?)
 
-      @threads << Thread.new(meta[:stdout], STDOUT) do |io, out|
+      Thread.new(@pipe) do |pipe|
         loop do
-          break unless synchro_readline(io, out)
+          begin
+            sleep 10
+            pipe.puts :gc
+          rescue StandardError => e
+            log "GC thread exception: #{e.inspect}"
+          end
         end
       end
 
-      @threads << Thread.new(meta[:stderr], STDERR) do |io, out|
-        loop do
-          break unless synchro_readline(io, out)
+      loop do
+        log 'Main loop...'
+        case event = @pipe.gets
+        when :term
+          log '  * Child terminated: try exits gracefully...'
+          terminate_all
+          loop_childs
+          quit!
+        when *(EXIT_SIGNALS + TERM_SIGNALS).map(&:to_sym)
+          log "  * Catch #{event}: try exits gracefully..."
+          terminate_all
+          loop_childs
+          quit!
+        when :child, :gc
+          log "  * Main loop event: #{event}"
+          loop_childs
+          quit! if @procs.all?(&:handled?)
+        else
+          log "  * Unknown event: #{event.inspect}"
+          loop_childs
+          quit! if @procs.all?(&:handled?)
         end
       end
-
-      log "Starting #{meta[:cmd]}"
-      meta[:pid] = meta[:process].start.pid
-
-      @procs.push(meta)
-      meta
     end
 
-    def synchro_readline(io, out)
-      str = io.gets
-      @lock.synchronize{ out.puts str }
-      true
-    rescue StandardError => e
-      false
-    end
+    private
 
-    def log(msg)
-      puts "[watcher]: #{msg}"
-    end
+      def collect_managed(pr, status = nil)
+        log 'Child finished'
+        log "  Process[#{pr.pid}]: #{pr.command}"
+        log "    status: #{(status || pr.status).inspect}"
 
-    def error(msg)
-      STDERR.puts "[watcher]: Error: #{msg}"
-    end
+        pr.stop!(status) if status
 
-    def exec
-      %w[EXIT QUIT].each do |sig|
-        trap(sig) do
-          stop_all
-        end
+        set_crash_report(pr) if pr.crashed?
       end
 
+      def collect_processes
+        pid, status = Process.waitpid2(-1, ::Process::WNOHANG | ::Process::WUNTRACED)
 
-      %w[INT TERM].each do |sig|
-        trap(sig) do
-          log "Catch #{sig}: try exits gracefully.."
-          stop_all
+        return false if pid.nil? || pid == 0
+
+        if pr = @procs.find {|pr| pr.pid == pid }
+          collect_managed(pr, status)
+          @pipe.puts :term
+        else
+          log "Unmanaged process finished: #{status.inspect}"
         end
+
+        true
+      rescue Errno::ECHILD, Errno::ESRCH
+        false
       end
 
-      trap('CLD') do |*_args|
-        unhandled = @procs.reject do |meta|
-          meta[:handled] || !meta[:process].exited?
+      def loop_childs
+        loop do
+          collected = collect_processes
+          break unless collected
         end
+      end
 
-        completed = unhandled.any? do |meta|
-          log 'Child finished'
-          log "  Process[#{meta[:pid]}]: #{meta[:cmd]}"
-          log "    status: #{meta[:process].crashed? ? 'crashed' : 'exited'}"
-          log "    code:   #{meta[:process].exit_code}"
+      def install_signal_handlers(pipe)
+        EXIT_SIGNALS.each do |sig|
+          trap(sig) do |*_args|
+            EXIT_SIGNALS.each do |sig|
+              trap(sig, 'IGNORE')
+            end
 
-          meta[:handled] = true
-          begin
-            meta[:stdin].close
-          rescue StandardError
-            nil
-          end
-          begin
-            meta[:stdout].close
-          rescue StandardError
-            nil
-          end
-          begin
-            meta[:stderr].close
-          rescue StandardError
-            nil
+            pipe.puts sig
           end
+        end
 
-          if !@crashed && meta[:process].crashed?
-            @crashed = true
-            @code = meta[:process].exit_code
-            @who = meta[:cmd]
-          end
+        TERM_SIGNALS.each do |sig|
+          trap(sig) do |*_args|
+            TERM_SIGNALS.each do |sig|
+              trap(sig) do |*_args|
+                STDERR.puts 'Forcing exit!'
+                exit!(1)
+              end
+            end
 
-          unless @stopping
-            log 'Try exits gracefully..'
-            stop_all
+            pipe.puts sig
           end
-
-          true
         end
 
-        unless completed
-          begin
-            pid, status = Process.waitpid2(-1, Process::WNOHANG)
-          rescue StandardError
-            nil
-          end
-          log "Subprocess finished: #{status.inspect}" if status
+        trap('CLD') do |*_args|
+          pipe.puts :child
         end
       end
 
-      begin
-        yield(self)
-      rescue StandardError => e
-        @crashed = true
-        @code = 1
-        error e.inspect
-        error e.backtrace.last(20).join("\n")
-        log 'Try exits gracefully..'
-        stop_all
-      end
-
-      @threads.map(&:join)
-
-      @code = [@code || 0, 1].max if @crashed
-
-      exit(@code || 0)
-    end
-
-
-
   end
 
 end

data/lib/aggkit/watcher/process_handler.rb

@@ -0,0 +1,172 @@
+require 'English'
+
+class Aggkit::Watcher::ProcessHandler
+
+  attr_accessor :watcher, :command, :options, :process, :stdin, :stdout, :stderr
+
+  def self.capture(cmd)
+    io = IO.popen(cmd)
+    output = io.read
+    begin
+      io.close
+    rescue StandardError
+      nil
+    end
+    [output, $?]
+  end
+
+  def initialize(watcher, *cmd)
+    @watcher = watcher
+
+    @options = if cmd.last.is_a? Hash
+      cmd.pop
+    else
+      {}
+    end
+
+    @command = cmd.flatten.map{|c| c.to_s.strip }.reject(&:empty?)
+    @process = build_process(*command)
+
+    initialize_streams
+
+    @process.start
+  end
+
+  def initialize_streams
+    @threads = []
+
+    @threads << Thread.new do
+      loop do
+        break unless synchro_readline(stdout, STDOUT)
+      end
+    end
+
+    @threads << Thread.new do
+      loop do
+        break unless synchro_readline(stderr, STDERR)
+      end
+    end
+  end
+
+  def synchro_readline(io, out)
+    str = io.gets
+    @watcher.iolock.synchronize{ out.puts(str) }
+    true
+  rescue StandardError
+    false
+  end
+
+  def build_process(*cmd)
+    pr = ::Aggkit::ChildProcess.build(*cmd)
+    @stdout, wout = IO.pipe
+    @stderr, werr = IO.pipe
+
+    @stdin = pr.io.stdin
+
+    pr.io.stdout = wout
+    pr.io.stderr = werr
+    pr.duplex = true
+    pr
+  end
+
+  def handled?
+    !!@process.exit_code
+  end
+
+  def stop!(status)
+    @process.send(:set_exit_code, status)
+    stop
+  end
+
+  def terminate
+    return if exited?
+    return if @terminating
+
+    @terminating = true
+
+    if @options[:termcmd]
+      termcmd = @options[:termcmd].gsub('%PID%', pid.to_s)
+      @watcher.log "Terminating by #{termcmd}..."
+      output, status = ::Aggkit::Watcher::ProcessHandler.capture(termcmd)
+
+      if status.success?
+        @watcher.log "Success: #{output}"
+      else
+        @watcher.error "Failed: #{output}"
+        @process.send(:send_term)
+      end
+    else
+      @process.send(:send_term)
+    end
+  end
+
+  def stop(timeout = (@options[:timeout] || 5))
+    return if exited?
+
+    terminate
+
+    begin
+      return poll_for_exit(timeout)
+    rescue TimeoutError
+      # try next
+    end
+
+    begin
+      @process.send(:send_kill)
+    rescue Errno::ECHILD, Errno::ESRCH
+      # handle race condition where process dies between timeout
+      # and send_kill
+    end
+
+    wait
+  ensure
+    clean_all
+  end
+
+  def method_missing(m, *args, &block)
+    if @process.respond_to? m
+      @process.send(m, *args, &block)
+    else
+      super
+    end
+  end
+
+  private
+
+    def clean_all
+      begin
+        @stdin.close
+      rescue StandardError
+        nil
+      end
+
+      begin
+        @stdout.close
+      rescue StandardError
+        nil
+      end
+
+      begin
+        @stderr.close
+      rescue StandardError
+        nil
+      end
+
+      @threads.each do |th|
+        begin
+          th.terminate
+        rescue StandardError
+          nil
+        end
+        begin
+          th.join
+        rescue StandardError
+          nil
+        end
+      end
+
+      @threads = []
+    end
+
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aggkit
 version: !ruby/object:Gem::Version
-  version: 0.3.8.9036
+  version: 0.4.0.9098
 platform: ruby
 authors:
 - Godko Ivan
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-27 00:00:00.000000000 Z
+date: 2019-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: diplomat
@@ -171,6 +171,7 @@ files:
 - lib/aggkit/runner.rb
 - lib/aggkit/version.rb
 - lib/aggkit/watcher.rb
+- lib/aggkit/watcher/process_handler.rb
 homepage: https://br.rnds.pro/aggredator/support/aggkit
 licenses:
 - MIT