main_loop 0.1.1.16821

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4995f3729d31c8254173cf965afa34b85e2925f5aef044f8c0f9d5355c01cf83
+  data.tar.gz: e0df7e76e16f78ddf26897fd3e2df03272c33768ffb4080b69874d859be32581
+SHA512:
+  metadata.gz: 0e3836071670675d4b55809c525c330dd6c9eeb9b75bb0375b30f9e43df425832bd9ebb57aa72cf8c90f549563e33e061bf7239cb10e3cbed7e198ebbc77ca81
+  data.tar.gz: d8c65293ee7b8ea5247d40b6d8a371078b1f77b00c0f87cc5890c1b07a6a2742672e94d7e84e2235ca58c88353d3ff0286fdf592b326f11e79cdab9afbc9c204

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2014-2019 Рнд Софт
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,68 @@
+# MainLoop
+
+[![Gem Version](https://badge.fury.io/rb/main_loop.svg)](https://rubygems.org/gems/main_loop)
+[![Gem](https://img.shields.io/gem/dt/main_loop.svg)](https://rubygems.org/gems/main_loop/versions)
+[![YARD](https://badgen.net/badge/YARD/doc/blue)](http://www.rubydoc.info/gems/main_loop)
+
+[![Test Coverage](https://api.codeclimate.com/v1/badges/ed48b89a9793a074cd23/test_coverage)](https://codeclimate.com/github/RnD-Soft/main_loop/test_coverage)
+[![Maintainability](https://api.codeclimate.com/v1/badges/ed48b89a9793a074cd23/maintainability)](https://codeclimate.com/github/RnD-Soft/main_loop/maintainability)
+[![Quality](https://lysander.x.rnds.pro/api/v1/badges/main_loop_quality.svg)](https://lysander.x.rnds.pro/api/v1/badges/main_loop_quality.html)
+[![Outdated](https://lysander.x.rnds.pro/api/v1/badges/main_loop_outdated.svg)](https://lysander.x.rnds.pro/api/v1/badges/main_loop_outdated.html)
+[![Vulnerabilities](https://lysander.x.rnds.pro/api/v1/badges/main_loop_vulnerable.svg)](https://lysander.x.rnds.pro/api/v1/badges/main_loop_vulnerable.html)
+
+MainLoop is a simple main application implementation to control subprocesses(children) and threads.
+
+Features:
+- reaping children
+- handling SIGTERM SIGINT to shutdown children(and threads) gracefully
+- restarting children
+- termination the children
+
+# Usage
+
+Example usage:
+
+```ruby
+require 'main_loop'
+
+logger = Logger.new(STDOUT)
+logger.level = Logger::DEBUG
+
+bus = MainLoop::Bus.new
+
+dispatcher = MainLoop::Dispatcher.new(bus, logger: logger)
+mainloop = MainLoop::Loop.new(bus, dispatcher, logger: logger)
+
+MainLoop::ProcessHandler.new dispatcher, 'test1', retry_count: 3, logger: logger do
+  sleep 2
+  exit! 0
+end
+
+MainLoop::ProcessHandler.new dispatcher, 'test2', retry_count: 2, logger: logger do
+  trap 'TERM' do
+    exit(0)
+  end
+  sleep 2
+  exit! 1
+end
+
+MainLoop::ThreadHandler.new dispatcher, 'thread2', retry_count: 0, logger: logger do
+  system('sleep 15;echo ok')
+end
+
+mainloop.run
+```
+
+
+# Installation
+
+It's a gem:
+```bash
+  gem install main_loop
+```
+There's also the wonders of [the Gemfile](http://bundler.io):
+```ruby
+  gem 'main_loop'
+```
+
+

data/lib/main_loop/bus.rb

@@ -0,0 +1,67 @@
+require 'monitor'
+require 'timeouter'
+
+module MainLoop
+  class Bus
+
+    include MonitorMixin
+
+    attr_reader :read, :write
+
+    EOL = "\n".freeze
+
+    def initialize
+      super()
+      @read, @write = IO.pipe
+      @read.sync = true
+      @write.sync = true
+      @buffer = ''
+    end
+
+    def empty?(timeout = 0)
+      !wait_for_event(timeout)
+    end
+
+    def close
+      @write.close rescue nil
+      @read.close rescue nil
+    end
+
+    def closed?
+      @write.closed? || @read.closed?
+    end
+
+    def puts(str)
+      synchronize do
+        @write.puts str.to_s
+      end
+    end
+
+    def wait_for_event(timeout)
+      IO.select([@read], [], [], timeout)
+    end
+
+    def gets(timeout)
+      Timeouter.loop(timeout) do |t|
+        line = gets_nonblock if wait_for_event(t.left)
+        return line if line
+      end
+    end
+
+    def gets_nonblock
+      while (ch = @read.read_nonblock(1))
+        @buffer << ch
+        next if ch != MainLoop::Bus::EOL
+
+        line = @buffer
+        @buffer = ''
+        return line&.strip
+      end
+      nil
+    rescue IO::WaitReadable
+      nil
+    end
+
+  end
+end
+

data/lib/main_loop/dispatcher.rb

@@ -0,0 +1,105 @@
+require 'monitor'
+require 'logger'
+
+module MainLoop
+  class Dispatcher
+
+    include MonitorMixin
+
+    attr_reader :bus, :handlers, :logger
+
+    def initialize(bus, timeout: 5, logger: nil)
+      super()
+      @bus = bus
+      @timeout = timeout
+      @handlers = []
+      @logger = logger || Logger.new(nil)
+    end
+
+    def reap(statuses)
+      statuses.each do |(pid, status)|
+        reap_by_id(pid, status)
+      end
+    end
+
+    def reap_by_id(id, status)
+      synchronize do
+        if (handler = handlers.find {|h| h.id == id })
+          logger.info("Reap handler #{handler.name.inspect}. Status: #{status.inspect}")
+          handler.reap(status)
+        else
+          logger.debug("Reap unknown handler. Status: #{status.inspect}. Skipped")
+        end
+      end
+    end
+
+    def add_handler(handler)
+      synchronize do
+        handler.term if terminating?
+        handlers << handler
+      end
+    end
+
+    def terminating?
+      @terminating_at
+    end
+
+    def term
+      synchronize do
+        if terminating?
+          logger.info('Terminate FORCE all handlers')
+          handlers.each(&:kill)
+        else
+          @terminating_at ||= Time.now
+          logger.info('Terminate all handlers')
+          handlers.each(&:term)
+        end
+      end
+    end
+
+    def tick
+      log_status if logger.debug?
+      return unless terminating?
+
+      try_exit!
+
+      return if @killed || !need_force_kill?
+
+      @killed = true
+      logger.info('Killing all handlers by timeout')
+      handlers.each(&:kill)
+    end
+
+    def need_force_kill?
+      @terminating_at && (Time.now - @terminating_at) >= @timeout
+    end
+
+    def pids
+      handlers.map{|h| h.pid rescue nil }.compact
+    end
+
+    # :nocov:
+    def try_exit!
+      synchronize do
+        return unless handlers.all?(&:finished?)
+
+        logger.info('All handlers finished exiting...')
+        status = handlers.all?(&:success?) ? 0 : 1
+        exit status
+      end
+    end
+    # :nocov:
+
+    # :nocov:
+    def log_status
+      total = handlers.size
+      running = handlers.count(&:running?)
+      finihsed = handlers.count(&:finished?)
+      term_text = terminating? ? 'TERM' : ''
+      logger.debug("Total:#{total} Running:#{running} Finihsed:#{finihsed}. #{term_text}".strip)
+    end
+    # :nocov:
+
+  end
+end
+

data/lib/main_loop/handler.rb

@@ -0,0 +1,91 @@
+require 'logger'
+
+module MainLoop
+  class Handler
+
+    attr_reader :dispatcher, :name, :logger
+
+    def initialize(dispatcher, name, *_args, retry_count: 0, logger: nil, **_kwargs)
+      @dispatcher = dispatcher
+      @name = name
+      @code = 0
+      @retry_count = retry_count
+      @logger = logger || Logger.new(nil)
+      @handler_type = 'Unknown'
+    end
+
+    # :nocov:
+    def id(*_args)
+      raise 'not implemented!'
+    end
+    # :nocov:
+
+    # :nocov:
+    def term(*_args)
+      raise 'not implemented!'
+    end
+    # :nocov:
+
+    # :nocov:
+    def run(*_args)
+      raise 'not implemented!'
+    end
+    # :nocov:
+
+    # :nocov:
+    def kill(*_args)
+      raise 'not implemented!'
+    end
+    # :nocov:
+
+    # :nocov:
+    def reap(*_args)
+      raise 'not implemented!'
+    end
+    # :nocov:
+
+    # :nocov:
+    def publish(event)
+      dispatcher.bus.puts(event)
+    end
+    # :nocov:
+
+    # :nocov:
+    def finished?
+      @finished
+    end
+    # :nocov:
+
+    # :nocov:
+    def success?
+      finished? && @success
+    end
+    # :nocov:
+
+    # :nocov:
+    def running?
+      !finished?
+    end
+    # :nocov:
+
+    # :nocov:
+    def terminating?
+      @terminating_at
+    end
+    # :nocov:
+
+    def handle_retry
+      if @retry_count == :unlimited
+        logger.info "#{@handler_type}[#{name}] retry...."
+        self.run(&@block)
+      elsif @retry_count && (@retry_count -= 1) >= 0
+        logger.info "#{@handler_type}[#{name}] retry...."
+        self.run(&@block)
+      else
+        publish(:term)
+      end
+    end
+
+  end
+end
+

data/lib/main_loop/loop.rb

@@ -0,0 +1,122 @@
+require 'logger'
+require 'timeouter'
+
+module MainLoop
+
+  TERM_SIGNALS = %w[INT TERM].freeze
+
+  class Loop
+
+    attr_reader :logger
+
+    def initialize(bus, dispatcher, logger: nil)
+      STDOUT.sync = true
+      STDERR.sync = true
+      @bus = bus
+      @dispatcher = dispatcher
+      @logger = logger || Logger.new(nil)
+    end
+
+    def run(timeout = 0)
+      install_signal_handlers(@bus)
+
+      start_loop_forever(timeout)
+    rescue StandardError => e
+      # :nocov:
+      logger.fatal("Exception in Main Loop: #{e.inspect}")
+      exit!(2)
+      # :nocov:
+    end
+
+    def start_loop_forever(timeout = 0)
+      wait = [timeout, 10].min
+      Timeouter.loop(timeout) do
+        event = @bus.gets(wait)
+        logger.debug("command:#{event}")
+
+        case event
+        when 'term'
+          term(event)
+        when /sig:/
+          signal(event)
+        when /reap:/
+          reap(event)
+        when nil
+          logger.debug('Empty event: reaping...')
+        else
+          logger.debug("unknown event:#{event}")
+        end
+
+        @dispatcher.reap(reap_children)
+        @dispatcher.tick
+      end
+    end
+
+    # :nocov:
+    def install_signal_handlers(bus)
+      TERM_SIGNALS.each do |sig|
+        trap(sig) do |*_args|
+          Thread.new(bus) {|b| b.puts "sig:#{sig}" }
+        end
+      end
+
+      trap 'CLD' do
+        Thread.new(bus) {|b| b.puts 'sig:CLD' }
+      end
+    end
+    # :nocov:
+
+    def signal(command)
+      _, sig = command.split(':')
+      logger.debug("signal:#{sig}")
+
+      if TERM_SIGNALS.include?(sig)
+        @dispatcher.term
+      elsif sig == 'CLD'
+        # nothing to do child will reap later
+      else
+        logger.info("unhandled signal:#{sig}")
+      end
+    end
+
+    def term(_command)
+      @dispatcher.term unless @dispatcher.terminating?
+    end
+
+    def reap(command)
+      _, id, status = command.split(':')
+      @dispatcher.reap_by_id(id, status)
+    end
+
+    def reap_children
+      results = []
+
+      @dispatcher.pids.each do |pid|
+        if (result = self.wait2(pid))
+          results << result
+        end
+      end
+
+      Timeouter.loop(2) do
+        unless (result = self.wait2(-1))
+          break
+        end
+
+        results << result
+      end
+
+      results
+    rescue Errno::ECHILD
+      results
+    end
+
+    # :nocov:
+    def wait2(pid)
+      Process.wait2(pid, ::Process::WNOHANG)
+    end
+    # :nocov:
+
+  end
+
+end
+

data/lib/main_loop/process_handler.rb

@@ -0,0 +1,81 @@
+require 'main_loop/handler'
+
+module MainLoop
+  class ProcessHandler < MainLoop::Handler
+
+    attr_reader :pid
+
+    def initialize(dispatcher, name, **kwargs, &block)
+      super
+      @handler_type = 'Process'
+      @pid = nil
+      dispatcher.add_handler(self)
+
+      run(&block) if block_given?
+    end
+
+    def id
+      @pid
+    end
+
+    def reap(status)
+      logger.info "Process[#{name}] exited: Pid:#{@pid} Status: #{status.exitstatus.inspect} Termsig: #{status.termsig.inspect} Success: #{status.success?}"
+      @pid = nil
+      @finished = true
+      @success = !!status.success?
+
+      return if terminating?
+
+      handle_retry
+    end
+
+    def term
+      unless @pid
+        @terminating_at ||= Time.now
+        logger.debug "Process[#{name}] alredy terminated. Skipped."
+        return
+      end
+
+      if terminating?
+        @success = false
+        logger.info "Process[#{name}] send force terminate: KILL Pid:#{@pid}"
+        ::Process.kill('KILL', @pid) rescue nil
+      else
+        @terminating_at ||= Time.now
+        logger.info "Process[#{name}] send terminate: Pid:#{@pid}"
+        ::Process.kill('TERM', @pid) rescue nil
+      end
+    end
+
+    def kill
+      unless @pid
+        logger.debug "Process[#{name}] alredy Killed. Skipped."
+        return
+      end
+
+      @success = false
+      logger.info "Process[#{name}] send kill: Pid:#{@pid}"
+      ::Process.kill('KILL', @pid) rescue nil
+    end
+
+    def run(&block)
+      return if terminating?
+
+      @block = block
+      start_fork(&@block)
+    end
+
+    protected
+
+      def start_fork
+        @pid = Kernel.fork do
+          yield
+        end
+        @finished = false
+        logger.info "Process[#{name}] created: Pid:#{@pid}"
+      end
+
+
+  end
+end
+

data/lib/main_loop/thread_handler.rb

@@ -0,0 +1,83 @@
+require 'main_loop/handler'
+
+module MainLoop
+
+  class ThreadHandler < MainLoop::Handler
+
+    attr_reader :thread
+
+    def initialize(dispatcher, name, **kwargs, &block)
+      super
+      @handler_type = 'Thread'
+      @thread = nil
+      dispatcher.add_handler(self)
+
+      run(&block) if block_given?
+    end
+
+    def id
+      @thread&.object_id.to_s
+    end
+
+    def reap(status)
+      logger.info "Thread[#{name}] exited: thread:#{@thread} Status:#{status}"
+      @thread = nil
+      @finished = true
+      @success = false
+
+      return if terminating?
+
+      handle_retry
+    end
+
+    def term
+      unless @thread
+        @terminating_at ||= Time.now
+        logger.debug "Thread[#{name}] alredy terminated. Skipped."
+        return
+      end
+
+      if terminating?
+        @success = false
+        logger.info "Thread[#{name}] send force terminate: KILL thread:#{@thread}"
+        @thread.kill rescue nil
+      else
+        @terminating_at ||= Time.now
+        logger.info "Thread[#{name}] send terminate: thread:#{@thread}"
+      end
+    end
+
+    def kill
+      unless @thread
+        logger.debug "Thread[#{name}] alredy Killed. Skipped."
+        return
+      end
+
+      @success = false
+      logger.info "Thread[#{name}] send kill: thread:#{@thread}"
+      @thread.kill rescue nil
+    end
+
+    def run(&block)
+      return if terminating?
+
+      @block = block
+      start_thread(&@block)
+    end
+
+    protected
+
+      def start_thread
+        @thread = Thread.new do
+          yield(self)
+        ensure
+          publish("reap:#{id}:exited")
+        end
+        @finished = false
+        logger.info "Thread[#{name}] created: thread:#{@thread}"
+      end
+
+
+  end
+end
+

data/lib/main_loop/version.rb

@@ -0,0 +1,6 @@
+module MainLoop
+
+  VERSION = '0.1.1'.freeze
+
+end
+

data/lib/main_loop.rb

@@ -0,0 +1,16 @@
+require 'main_loop/bus'
+require 'main_loop/loop'
+require 'main_loop/dispatcher'
+require 'main_loop/process_handler'
+require 'main_loop/thread_handler'
+
+
+
+module MainLoop
+
+  class << self
+
+  end
+
+end
+

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: main_loop
+version: !ruby/object:Gem::Version
+  version: 0.1.1.16821
+platform: ruby
+authors:
+- Samoilenko Yuri
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-09-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec_junit_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov-console
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: timeouter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Main Loop implementation to control subprocesses and threads
+email:
+- kinnalru@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/main_loop.rb
+- lib/main_loop/bus.rb
+- lib/main_loop/dispatcher.rb
+- lib/main_loop/handler.rb
+- lib/main_loop/loop.rb
+- lib/main_loop/process_handler.rb
+- lib/main_loop/thread_handler.rb
+- lib/main_loop/version.rb
+homepage: https://github.com/RnD-Soft/main_loop
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Main Loop implementation to control subprocesses and threads
+test_files: []