forked 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1f591d8bc0b287d508ca0663dc5da9eaff43aaf9e52dd493650a415e2e8046a6
+  data.tar.gz: aad8dbad91f2ad51f369e05966ba99ae743c36f4e60d596df65f2db468c79e13
+SHA512:
+  metadata.gz: bd13eeacb29d220bf95083e5339797ff4af2e930719461faa8271e68fffed1f58928db4d43d57e3d8dd6a767e96b328c926072363e797b078aa59b66b23d03fc
+  data.tar.gz: 03fcc1b66c0d23c224e00f84315ba789679fd07bd7ce9a1b61704a3bd1b58d8f8b70abc1ca8099c6cfc1cea1471f6ebfd3d4e22cc361bfd1d0cf9c5858f6ba97

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,41 @@
+PATH
+  remote: .
+  specs:
+    forked (0.1.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.2)
+    diff-lcs (1.3)
+    method_source (0.9.0)
+    pry (0.11.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rake (10.5.0)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.0)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.15)
+  forked!
+  pry
+  rake (~> 10.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   1.16.1

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2018 Envato
+
+MIT License
+
+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,47 @@
+# Forked
+
+Forked manages long running worker processes.
+
+Processes that crash are restarted, whereas processes that exit successfully
+aren't. Errors that occur within forked processes are retried according to the
+configured retry strategy.
+
+Once `wait_for_shutdown` is called, the current process watches for shutdown
+signals or crashed processes. On shutdown, each worker is sent a TERM signal,
+indicating that it should finish any in progress work and shutdown. After a set
+timeout period workers are sent a KILL signal.
+
+## Usage
+
+```ruby
+require 'forked'
+
+process_manager = Forked::ProcessManager.new(logger: Logger.new(STDOUT), process_timeout: 5)
+
+process_manager.fork('monitor', on_error: ->(e) { puts e.inspect }) do
+  loop do
+    puts "hi"
+    sleep 1
+  end
+end
+
+process_manager.fork('processor_1', retry_strategy: Forked::RetryStrategies::ExponentialBackoff) do |ready_to_stop|
+  loop do
+    ready_to_stop.call # triggers a shutdown if a TERM/INT signal has been received
+    # do something
+  end
+end
+
+# blocks the current process, restarts any crashed processes and waits for shutdown signals (TERM/INT).
+process_manager.wait_for_shutdown
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/envato/forked.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/forked.rb

@@ -0,0 +1,9 @@
+require 'forked/version'
+require 'forked/worker'
+require 'forked/retry_strategies/always'
+require 'forked/retry_strategies/exponential_backoff'
+require 'forked/process_manager'
+require 'forked/with_graceful_shutdown'
+
+module Forked
+end

data/lib/forked/process_manager.rb

@@ -0,0 +1,117 @@
+require 'logger'
+require 'timeout'
+
+module Forked
+  class ProcessManager
+    def initialize(process_timeout: 5, logger: Logger.new(STDOUT))
+      @process_timeout = process_timeout
+      @workers = {}
+      @logger = logger
+    end
+
+    def fork(name = nil, retry_strategy: ::Forked::RetryStrategies::ExponentialBackoff, on_error: -> (e) {}, &block)
+      worker = Worker.new(name, retry_strategy, on_error, block)
+      fork_worker(worker)
+    end
+
+    def wait_for_shutdown
+      trap_shutdown_signals
+      handle_child_processes
+      shutdown
+    end
+
+    def shutdown
+      @logger.info "Master shutting down"
+      send_signal_to_workers(:TERM)
+      wait_for_workers_until_timeout
+      send_signal_to_workers(:KILL)
+      @logger.info "Master shutdown complete"
+    end
+
+    def worker_pids
+      @workers.keys
+    end
+
+    private
+
+    def fork_worker(worker)
+      retry_strategy = worker.retry_strategy.new(logger: @logger, on_error: worker.on_error)
+      pid = Kernel.fork do
+        WithGracefulShutdown.run(logger: @logger) do |ready_to_stop|
+          retry_strategy.run(ready_to_stop) do
+            if worker.block.arity > 0
+              worker.block.call(ready_to_stop)
+            else
+              worker.block.call
+            end
+          end
+        end
+      end
+      @workers[pid] = worker
+    end
+
+    def handle_child_processes
+      until @shutdown_requested
+        # Returns nil immediately if no child process exists
+        pid, status = Process.wait2(-1, Process::WNOHANG)
+        if pid
+          handle_child_exit(pid, status)
+        end
+        sleep(0.5)
+      end
+    end
+
+    def handle_child_exit(pid, status)
+      worker = @workers.delete(pid)
+      if status.exited?
+        @logger.info "#{worker.name || pid} exited with status #{status.exitstatus.inspect}"
+      else
+        @logger.info "#{worker.name || pid} terminated"
+      end
+      if status.exitstatus.nil? || status.exitstatus.nonzero?
+        @logger.error "Restarting #{worker.name || pid}"
+        fork_worker(worker)
+      end
+    end
+
+    def trap_shutdown_signals
+      %i(TERM INT).each do |signal|
+        Signal.trap(signal) do
+          start_shutdown
+        end
+      end
+    end
+
+    def start_shutdown
+      @shutdown_requested = true
+    end
+
+    def wait_for_workers_until_timeout
+      @waiting_since = Time.now
+      until @workers.empty? || timed_out?(@waiting_since)
+        # Returns nil immediately if no child process exists
+        pid, status = Process.wait2(-1, Process::WNOHANG)
+        @workers.delete(pid) if pid
+      end
+    end
+
+    def send_signal_to_workers(signal)
+      if !@workers.empty?
+        @logger.info "Sending #{signal} to #{@workers.keys}"
+        @workers.each_key do |pid|
+          begin
+            Process.kill(signal, pid)
+          rescue Errno::ESRCH => e
+            # Errno::ESRCH: No such process
+            # Move along if the process is already dead
+            @workers.delete(pid)
+          end
+        end
+      end
+    end
+
+    def timed_out?(waiting_since)
+      Time.now > (waiting_since + @process_timeout)
+    end
+  end
+end

data/lib/forked/retry_strategies/always.rb

@@ -0,0 +1,19 @@
+module Forked
+  module RetryStrategies
+    # Relies on the master restarting the worker process
+    class Always
+      def initialize(logger:, on_error:)
+        @logger = logger
+        @on_error = on_error
+      end
+
+      def run(ready_to_stop, &block)
+        block.call
+      rescue => e
+        @logger.error("#{e.class} #{e.message}")
+        @on_error.call(e, 1)
+        raise
+      end
+    end
+  end
+end

data/lib/forked/retry_strategies/exponential_backoff.rb

@@ -0,0 +1,28 @@
+module Forked
+  module RetryStrategies
+    class ExponentialBackoff
+      def initialize(logger:, on_error:, backoff_factor: 2)
+        @logger = logger
+        @on_error = on_error
+        @backoff_factor = backoff_factor
+      end
+
+      def run(ready_to_stop, &block)
+        tries = 0
+        begin
+          block.call
+        rescue => e
+          tries += 1
+          sleep_seconds = @backoff_factor**tries
+          @logger.error("#{e.class} #{e.message}")
+          @on_error.call(e, tries)
+          sleep_seconds.times do
+            ready_to_stop.call
+            sleep 1
+          end
+          retry
+        end
+      end
+    end
+  end
+end

data/lib/forked/version.rb

@@ -0,0 +1,3 @@
+module Forked
+  VERSION = "0.1.1"
+end

data/lib/forked/with_graceful_shutdown.rb

@@ -0,0 +1,72 @@
+# Traps SIGTERM and SIGINT and shuts down only when the block
+# is called, allowing for graceful shutdown.
+#
+# @example
+#   WithGracefulShutdown.run do |ready_to_stop|
+#     loop do
+#       # do some work
+#       ready_to_stop.call
+#     end
+#   end
+#
+# @example
+#   WithGracefulShutdown.loop(sleep_seconds: 2) do |ready_to_stop|
+#     print '.'
+#   end
+module Forked
+  class WithGracefulShutdown
+    def self.loop(sleep_seconds: 1, &block)
+      run do |ready_to_stop|
+        Kernel.loop do
+          ready_to_stop.call
+          yield ready_to_stop
+          ready_to_stop.call
+          sleep_seconds.times do
+            ready_to_stop.call
+            sleep(1)
+          end
+        end
+      end
+    end
+
+    def self.run(logger: Logger.new(STDOUT), &block)
+      new(logger: logger).run(&block)
+    end
+
+    def initialize(logger:)
+      @logger = logger
+      @shutdown = false
+    end
+
+    def run
+      trap_shutdown_signals do
+        catch(:stop) do
+          ready_to_stop = -> { stop_if_necessary }
+          yield ready_to_stop
+        end
+      end
+    end
+
+    def stop_if_necessary
+      if @shutdown
+        @logger.info("Shutting down")
+        throw :stop
+      end
+    end
+
+    def shutdown
+      @shutdown = true
+    end
+
+    private
+
+    def trap_shutdown_signals
+      orig_int_handler = Signal.trap(:INT) { shutdown }
+      orig_term_handler = Signal.trap(:TERM) { shutdown }
+      yield
+    ensure
+      Signal.trap(:INT, orig_int_handler)
+      Signal.trap(:TERM, orig_term_handler)
+    end
+  end
+end

data/lib/forked/worker.rb

@@ -0,0 +1,4 @@
+module Forked
+  class Worker < Struct.new(:name, :retry_strategy, :on_error, :block)
+  end
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: forked
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Steve Hodgkiss
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-08-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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'
+description: ''
+email:
+- steve@hodgkiss.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/forked.rb
+- lib/forked/process_manager.rb
+- lib/forked/retry_strategies/always.rb
+- lib/forked/retry_strategies/exponential_backoff.rb
+- lib/forked/version.rb
+- lib/forked/with_graceful_shutdown.rb
+- lib/forked/worker.rb
+homepage: https://github.com/envato/forked
+licenses: []
+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: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Manage long running forked processes
+test_files: []