service_skeleton 0.0.0.1.ENOTAG → 0.0.0.2.g46c1e0e

data/ultravisor/lib/ultravisor.rb

@@ -1,216 +0,0 @@
-# frozen_string_literal: true
-
-require "logger"
-
-require_relative "./ultravisor/child"
-require_relative "./ultravisor/error"
-require_relative "./ultravisor/logging_helpers"
-
-# A super-dooOOOoooper supervisor.
-#
-class Ultravisor
-  include LoggingHelpers
-
-  def initialize(children: [], strategy: :one_for_one, logger: Logger.new("/dev/null"))
-    @queue, @logger = Queue.new, logger
-
-    @strategy = strategy
-    validate_strategy
-
-    @op_m, @op_cv = Mutex.new, ConditionVariable.new
-    @running_thread = nil
-
-    initialize_children(children)
-  end
-
-  def run
-    logger.debug(logloc) { "called" }
-
-    @op_m.synchronize do
-      if @running_thread
-        raise AlreadyRunningError,
-              "This ultravisor is already running"
-      end
-
-      @queue.clear
-      @running_thread = Thread.current
-      Thread.current.name = "Ultravisor"
-    end
-
-    logger.debug(logloc) { "Going to start children #{@children.map(&:first).inspect}" }
-    @children.each { |c| c.last.spawn(@queue) }
-
-    process_events
-
-    @op_m.synchronize do
-      logger.debug(logloc) { "Shutdown time for #{@children.reverse.map(&:first).inspect}" }
-      @children.reverse.each { |c| c.last.shutdown }
-
-      @running_thread = nil
-      @op_cv.broadcast
-    end
-
-    self
-  end
-
-  def shutdown(wait: true, force: false)
-    @op_m.synchronize do
-      return self unless @running_thread
-      if force
-        @children.reverse.each { |c| c.last.shutdown(force: true) }
-        @running_thread.kill
-        @running_thread = nil
-        @op_cv.broadcast
-      else
-        @queue << :shutdown
-        if wait
-          @op_cv.wait(@op_m) while @running_thread
-        end
-      end
-    end
-    self
-  end
-
-  def [](id)
-    @children.assoc(id)&.last
-  end
-
-  def add_child(**args)
-    logger.debug(logloc) { "Adding child #{args[:id].inspect}" }
-    args[:logger] ||= logger
-
-    @op_m.synchronize do
-      c = Ultravisor::Child.new(**args)
-
-      if @children.assoc(c.id)
-        raise DuplicateChildError,
-              "Child with ID #{c.id.inspect} already exists"
-      end
-
-      @children << [c.id, c]
-
-      if @running_thread
-        logger.debug(logloc) { "Auto-starting new child #{args[:id].inspect}" }
-        c.spawn(@queue)
-      end
-    end
-  end
-
-  def remove_child(id)
-    logger.debug(logloc) { "Removing child #{id.inspect}" }
-
-    @op_m.synchronize do
-      c = @children.assoc(id)
-
-      return nil if c.nil?
-
-      @children.delete(c)
-      if @running_thread
-        logger.debug(logloc) { "Shutting down removed child #{id.inspect}" }
-        c.last.shutdown
-      end
-    end
-  end
-
-  private
-
-  def validate_strategy
-    unless %i{one_for_one all_for_one rest_for_one}.include?(@strategy)
-      raise ArgumentError,
-            "Invalid strategy #{@strategy.inspect}"
-    end
-  end
-
-  def initialize_children(children)
-    unless children.is_a?(Array)
-      raise ArgumentError,
-            "children must be an Array"
-    end
-
-    @children = []
-
-    children.each do |cfg|
-      cfg[:logger] ||= logger
-      c = Ultravisor::Child.new(**cfg)
-      if @children.assoc(c.id)
-        raise DuplicateChildError,
-              "Duplicate child ID: #{c.id.inspect}"
-      end
-
-       @children << [c.id, c]
-    end
-  end
-
-  def process_events
-    loop do
-      qe = @queue.pop
-
-      case qe
-      when Ultravisor::Child
-        logger.debug(logloc) { "Received Ultravisor::Child queue entry for #{qe.id}" }
-        @op_m.synchronize { child_exited(qe) }
-      when :shutdown
-        logger.debug(logloc) { "Received :shutdown queue entry" }
-        break
-      else
-        logger.error(logloc) { "Unknown queue entry: #{qe.inspect}" }
-      end
-    end
-  end
-
-  def child_exited(child)
-    if child.termination_exception
-      log_exception(child.termination_exception, "Ultravisor::Child(#{child.id.inspect})") { "Thread terminated by unhandled exception" }
-    end
-
-    if @running_thread.nil?
-      logger.debug(logloc) { "Child termination after shutdown" }
-      # Child termination processed after we've shut down... nope
-      return
-    end
-
-    begin
-      return unless child.restart?
-    rescue Ultravisor::BlownRestartPolicyError
-      # Uh oh...
-      logger.error(logloc) { "Child #{child.id} has exceeded its restart policy.  Shutting down the Ultravisor." }
-      @queue << :shutdown
-      return
-    end
-
-    case @strategy
-    when :all_for_one
-      @children.reverse.each do |id, c|
-        # Don't need to shut down the child that has caused all this mess
-        next if child.id == id
-
-        c.shutdown
-      end
-    when :rest_for_one
-      @children.reverse.each do |id, c|
-        # Don't go past the child that caused the problems
-        break if child.id == id
-
-        c.shutdown
-      end
-    end
-
-    sleep child.restart_delay
-
-    case @strategy
-    when :all_for_one
-      @children.each do |_, c|
-        c.spawn(@queue)
-      end
-    when :rest_for_one
-      s = false
-      @children.each do |id, c|
-        s = true if child.id == id
-
-        c.spawn(@queue) if s
-      end
-    when :one_for_one
-      child.spawn(@queue)
-    end
-  end
-end

data/ultravisor/spec/example_group_methods.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require 'logger'
-
-module ExampleGroupMethods
-  def uses_logger
-    let(:logger) { instance_double(Logger, 'mock') }
-
-    before(:each) do
-      allow(Logger).to receive(:new).and_return(logger)
-      allow(logger).to receive(:debug).with(instance_of(String))
-      allow(logger).to receive(:info).with(instance_of(String))
-      allow(logger).to receive(:error) { |p, &m| puts "#{p}: #{m.call}" }
-      allow(logger).to receive(:level=).with(Logger::INFO)
-      allow(logger).to receive(:formatter=).with(an_instance_of(Proc))
-      allow(logger).to receive(:kind_of?).with(Logger).and_return(true)
-    end
-  end
-end

data/ultravisor/spec/example_methods.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-module ExampleMethods
-  def tmptrace
-    require "tracer"
-    Tracer.add_filter { |event, file, line, id, binding, klass, *rest| klass.to_s =~ /Ultravisor/ }
-    Tracer.on { yield }
-  end
-end

data/ultravisor/spec/spec_helper.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-require 'bundler'
-Bundler.setup(:default, :development)
-require 'rspec/core'
-require 'rspec/mocks'
-
-Thread.report_on_exception = false
-
-require 'simplecov'
-SimpleCov.start do
-  add_filter('spec')
-end
-
-class ListIncompletelyCoveredFiles
-  def format(result)
-    incompletes = result.files.select { |f| f.covered_percent < 100 }
-
-    unless incompletes.empty?
-      puts
-      puts "Files with incomplete test coverage:"
-      incompletes.each do |f|
-        printf "    %2.01f%%    %s\n", f.covered_percent, f.filename
-      end
-      puts; puts
-    end
-  end
-end
-
-SimpleCov.formatters = SimpleCov::Formatter::MultiFormatter.new([
-  SimpleCov::Formatter::HTMLFormatter,
-  ListIncompletelyCoveredFiles
-])
-
-require_relative "./example_group_methods"
-require_relative "./example_methods"
-
-RSpec.configure do |config|
-  config.extend ExampleGroupMethods
-  config.include ExampleMethods
-
-  config.order = :random
-  config.fail_fast = !!ENV["RSPEC_CONFIG_FAIL_FAST"]
-  config.full_backtrace = !!ENV["RSPEC_CONFIG_FULL_BACKTRACE"]
-
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-  end
-end

data/ultravisor/spec/ultravisor/add_child_spec.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-require_relative "../spec_helper"
-
-require_relative "../../lib/ultravisor"
-
-describe Ultravisor do
-  let(:args) { {} }
-  let(:ultravisor) { Ultravisor.new(**args) }
-  let!(:child) { Ultravisor::Child.new(id: :xtra, klass: Class, method: :to_s) }
-
-  describe "#add_child" do
-    before(:each) do
-      allow(Ultravisor::Child).to receive(:new).and_return(child)
-    end
-
-    context "when the ultravisor isn't running" do
-      it "creates a new Child object" do
-        expect(Ultravisor::Child).to receive(:new).with(id: :xtra, klass: Class, method: :to_s, logger: instance_of(Logger))
-
-        ultravisor.add_child(id: :xtra, klass: Class, method: :to_s)
-      end
-
-      it "registers the new child" do
-        ultravisor.add_child(id: :xtra, klass: Class, method: :to_s)
-
-        expect(ultravisor[:xtra]).to be_a(Ultravisor::Child)
-      end
-
-      it "explodes if a dupe child ID is used" do
-        ultravisor.add_child(id: :xtra, klass: Class, method: :to_s)
-
-        expect do
-          ultravisor.add_child(id: :xtra, klass: Object, method: :to_s)
-        end.to raise_error(Ultravisor::DuplicateChildError)
-      end
-
-      it "doesn't spawn a child thread" do
-        expect(child).to_not receive(:spawn)
-
-        ultravisor.add_child(id: :xtra, klass: Class, method: :to_s)
-      end
-    end
-
-    context "while the ultravisor *is* running" do
-      let(:mock_thread) { instance_double(Thread) }
-
-      before(:each) do
-        allow(child).to receive(:spawn)
-        ultravisor.instance_variable_set(:@running_thread, mock_thread)
-      end
-
-      it "creates a new Child object" do
-        expect(Ultravisor::Child).to receive(:new).with(id: :xtra, klass: Class, method: :to_s, logger: instance_of(Logger))
-
-        ultravisor.add_child(id: :xtra, klass: Class, method: :to_s)
-      end
-
-      it "registers the new child" do
-        ultravisor.add_child(id: :xtra, klass: Class, method: :to_s)
-
-        expect(ultravisor[:xtra]).to be_a(Ultravisor::Child)
-      end
-
-      it "explodes if a dupe child ID is used" do
-        ultravisor.add_child(id: :xtra, klass: Class, method: :to_s)
-
-        expect do
-          ultravisor.add_child(id: :xtra, klass: Object, method: :to_s)
-        end.to raise_error(Ultravisor::DuplicateChildError)
-      end
-
-      it "spawns a child thread" do
-        ultravisor.add_child(id: :xtra, klass: Class, method: :to_s)
-
-        expect(child).to have_received(:spawn)
-      end
-    end
-  end
-end

data/ultravisor/spec/ultravisor/child/call_spec.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../../spec_helper"
-
-require_relative "../../../lib/ultravisor/child"
-require_relative "../../../lib/ultravisor/error"
-
-class CastCallTest
-  class FakeError < RuntimeError; end
-
-  def run
-  end
-
-  def poke_processor
-    process_castcall
-  end
-
-  def failing_method
-    raise FakeError
-  end
-end
-
-describe Ultravisor::Child do
-  let(:child) { Ultravisor::Child.new(**args) }
-  let(:instance) { child.__send__(:new_instance) }
-
-  describe "#call" do
-    context "without enable_castcall" do
-      let(:args) do
-        {
-          id: :call_child,
-          klass: CastCallTest,
-          method: :run,
-        }
-      end
-
-      it "does not accept calls to #call" do
-        expect { child.call }.to raise_error(NoMethodError)
-      end
-    end
-
-    context "with enable_castcall" do
-      let(:args) do
-        {
-          id: :call_child,
-          klass: CastCallTest,
-          method: :run,
-          enable_castcall: true,
-        }
-      end
-
-      before(:each) do
-        # Got to have an instance otherwise all hell breaks loose
-        child.instance_variable_set(:@instance, instance)
-
-        # So we can check if and when it's been called
-        allow(instance).to receive(:to_s).and_call_original
-        allow(instance).to receive(:failing_method).and_call_original
-      end
-
-      it "accepts calls to #call" do
-        expect { child.call }.to_not raise_error
-      end
-
-      it "does not accept call calls to methods that do not exist on the worker object" do
-        expect { child.call.flibbetygibbets }.to raise_error(NoMethodError)
-      end
-
-      it "does not accept call calls to private methods on the worker object" do
-        expect { child.call.eval }.to raise_error(NoMethodError)
-      end
-
-      it "accepts calls to methods that exist on the worker object" do
-        th = Thread.new { child.call.to_s }
-        th.join(0.01)
-        instance.poke_processor
-        expect { th.value }.to_not raise_error
-      end
-
-      it "calls the instance method only when process_castcall is called" do
-        th = Thread.new { child.call.to_s }
-        th.join(0.001)
-
-        # Thread should be ticking along, not dead
-        expect(th.status).to eq("sleep")
-        expect(instance).to_not have_received(:to_s)
-        instance.poke_processor
-        expect(instance).to have_received(:to_s)
-        expect(th.value).to be_a(String)
-      end
-
-      it "raises a relevant error if the call itself causes an exception is dying" do
-        th = Thread.new { child.call.failing_method }
-        th.join(0.001)
-
-        expect(instance).to_not have_received(:failing_method)
-        expect { instance.poke_processor }.to raise_error(CastCallTest::FakeError)
-        expect(instance).to have_received(:failing_method)
-
-        expect { th.value }.to raise_error(Ultravisor::ChildRestartedError)
-      end
-
-      it "raises a relevant error if the instance is dying" do
-        instance.instance_variable_get(:@ultravisor_child_castcall_queue).close
-
-        expect { child.call.to_s }.to raise_error(Ultravisor::ChildRestartedError)
-      end
-
-      it "raises an error to all incomplete calls if the instance terminates" do
-        th = Thread.new { child.call.to_s }
-
-        th.join(0.001) until th.status == "sleep"
-
-        expect(instance).to_not have_received(:to_s)
-        child.instance_variable_get(:@spawn_m).synchronize { child.__send__(:termination_cleanup) }
-
-        expect { th.value }.to raise_error(Ultravisor::ChildRestartedError)
-      end
-    end
-  end
-end

data/ultravisor/spec/ultravisor/child/cast_spec.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../../spec_helper"
-
-require_relative "../../../lib/ultravisor/child"
-require_relative "../../../lib/ultravisor/error"
-
-class CastCallTest
-  def run
-  end
-
-  def poke_processor
-    process_castcall
-  end
-end
-
-describe Ultravisor::Child do
-  let(:child) { Ultravisor::Child.new(**args) }
-  let(:instance) { child.__send__(:new_instance) }
-
-  describe "#cast" do
-    context "without enable_castcall" do
-      let(:args) do
-        {
-          id: :cast_child,
-          klass: CastCallTest,
-          method: :run,
-        }
-      end
-
-      it "does not accept calls to #cast" do
-        expect { child.cast }.to raise_error(NoMethodError)
-      end
-    end
-
-    context "with enable_castcall" do
-      let(:args) do
-        {
-          id: :cast_child,
-          klass: CastCallTest,
-          method: :run,
-          enable_castcall: true,
-        }
-      end
-
-      before(:each) do
-        # Got to have an instance otherwise all hell breaks loose
-        child.instance_variable_set(:@instance, instance)
-
-        # So we can check if and when it's been called
-        allow(instance).to receive(:to_s).and_call_original
-      end
-
-      it "accepts calls to #cast" do
-        expect { child.cast }.to_not raise_error
-      end
-
-      it "does not accept cast calls to methods that do not exist on the worker object" do
-        expect { child.cast.flibbetygibbets }.to raise_error(NoMethodError)
-      end
-
-      it "does not accept cast calls to private methods on the worker object" do
-        expect { child.cast.eval }.to raise_error(NoMethodError)
-      end
-
-      it "accepts calls to methods that exist on the worker object" do
-        expect { child.cast.to_s }.to_not raise_error
-      end
-
-      it "calls the instance method only when process_castcall is called" do
-        child.cast.to_s
-        expect(instance).to_not have_received(:to_s)
-        instance.poke_processor
-        expect(instance).to have_received(:to_s)
-      end
-
-      it "processes all the queued method calls" do
-        child.cast.to_s
-        child.cast.to_s
-        child.cast.to_s
-        child.cast.to_s
-        child.cast.to_s
-        expect(instance).to_not have_received(:to_s)
-        instance.poke_processor
-        expect(instance).to have_received(:to_s).exactly(5).times
-      end
-
-      let(:cc_fd) { instance.__send__(:castcall_fd) }
-      it "marks the castcall_fd as readable only after cast is called" do
-        expect(IO.select([cc_fd], nil, nil, 0)).to eq(nil)
-
-        child.cast.to_s
-
-        expect(IO.select([cc_fd], nil, nil, 0)).to eq([[cc_fd], [], []])
-      end
-
-      it "does not have a readable castcall_fd after process_castcall" do
-        child.cast.to_s
-        expect(IO.select([cc_fd], nil, nil, 0)).to eq([[cc_fd], [], []])
-        instance.poke_processor
-        expect(IO.select([cc_fd], nil, nil, 0)).to eq(nil)
-      end
-
-      it "does not explode if the instance is dying" do
-        instance.instance_variable_get(:@ultravisor_child_castcall_queue).close
-
-        expect { child.cast.to_s }.to_not raise_error
-      end
-    end
-  end
-end

data/ultravisor/spec/ultravisor/child/id_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../../spec_helper"
-
-require_relative "../../../lib/ultravisor/child"
-require_relative "../../../lib/ultravisor/error"
-
-describe Ultravisor::Child do
-  let(:child) { Ultravisor::Child.new(**args) }
-  let(:mock_class) { Class.new.tap { |k| k.class_eval { def run; end } } }
-
-  describe "#id" do
-    context "with minimal arguments" do
-      let(:args) { { id: :bob, klass: mock_class, method: :run } }
-
-      it "returns the child's ID" do
-        expect(child.id).to eq(:bob)
-      end
-    end
-  end
-end