Proposed SysV structures and Mixin functionality

lib/semian.rb

@@ -124,7 +124,8 @@ def register(name, tickets:, permissions: 0660, timeout: 0, error_threshold:, er
       error_threshold: error_threshold,
       error_timeout: error_timeout,
       exceptions: Array(exceptions) + [::Semian::BaseError],
-      implementation: ::Semian::Simple,
+      permissions: permissions,
+      implementation: ::Semian::SysV,
     )
     resource = Resource.new(name, tickets: tickets, permissions: permissions, timeout: timeout)
     resources[name] = ProtectedResource.new(resource, circuit_breaker)
@@ -159,6 +160,10 @@ def resources
 require 'semian/simple_sliding_window'
 require 'semian/simple_integer'
 require 'semian/simple_state'
+require 'semian/sysv_shared_memory'
+require 'semian/sysv_sliding_window'
+require 'semian/sysv_integer'
+require 'semian/sysv_state'
 if Semian.semaphores_enabled?
   require 'semian/semian'
 else

lib/semian/circuit_breaker.rb

@@ -2,16 +2,20 @@ module Semian
   class CircuitBreaker #:nodoc:
     extend Forwardable
 
-    def initialize(name, exceptions:, success_threshold:, error_threshold:, error_timeout:, implementation:)
+    def initialize(name, exceptions:, success_threshold:, error_threshold:, error_timeout:, permissions:, implementation:)
       @name = name.to_sym
       @success_count_threshold = success_threshold
       @error_count_threshold = error_threshold
       @error_timeout = error_timeout
       @exceptions = exceptions
 
-      @errors = implementation::SlidingWindow.new(max_size: @error_count_threshold)
-      @successes = implementation::Integer.new
-      @state = implementation::State.new
+      @errors = implementation::SlidingWindow.new(max_size: @error_count_threshold,
+                                                  name: "#{name}_sysv_sliding_window",
+                                                  permissions: permissions)
+      @successes = implementation::Integer.new(name: "#{name}_sysv_integer",
+                                               permissions: permissions)
+      @state = implementation::State.new(name: "#{name}_sysv_state",
+                                         permissions: permissions)
     end
 
     def acquire

lib/semian/simple_integer.rb

@@ -3,7 +3,7 @@ module Simple
     class Integer #:nodoc:
       attr_accessor :value
 
-      def initialize
+      def initialize(**)
         reset
       end
 

lib/semian/simple_sliding_window.rb

@@ -1,3 +1,5 @@
+require 'forwardable'
+
 module Semian
   module Simple
     class SlidingWindow #:nodoc:
@@ -10,7 +12,7 @@ class SlidingWindow #:nodoc:
       # like this: if @max_size = 4, current time is 10, @window =[5,7,9,10].
       # Another push of (11) at 11 sec would make @window [7,9,10,11], shifting off 5.
 
-      def initialize(max_size:)
+      def initialize(max_size:, **)
         @max_size = max_size
         @window = []
       end

lib/semian/simple_state.rb

@@ -1,7 +1,7 @@
 module Semian
   module Simple
     class State #:nodoc:
-      def initialize
+      def initialize(**)
         reset
       end
 

lib/semian/sysv_integer.rb

@@ -0,0 +1,12 @@
+module Semian
+  module SysV
+    class Integer < Semian::Simple::Integer #:nodoc:
+      include SysVSharedMemory
+
+      def initialize(name:, permissions:)
+        data_layout = [:int]
+        super() unless acquire_memory_object(name, data_layout, permissions)
+      end
+    end
+  end
+end

lib/semian/sysv_shared_memory.rb

@@ -0,0 +1,75 @@
+module Semian
+  module SysVSharedMemory #:nodoc:
+    @type_size = {}
+    def self.sizeof(type)
+      size = (@type_size[type.to_sym] ||= (respond_to?(:_sizeof) ? _sizeof(type.to_sym) : 0))
+      raise TypeError.new("#{type} is not a valid C type") if size <= 0
+      size
+    end
+
+    def self.included(base)
+      def base.do_with_sync(*names)
+        names.each do |name|
+          new_name = "#{name}_inner".freeze.to_sym
+          alias_method new_name, name
+          private new_name
+          define_method(name) do |*args, &block|
+            synchronize do
+              method(new_name).call(*args, &block)
+            end
+          end
+        end
+      end
+    end
+
+    def semid
+      -1
+    end
+
+    def shmid
+      -1
+    end
+
+    def synchronize(&block)
+      if respond_to?(:_synchronize) && @using_shared_memory
+        return _synchronize(&block)
+      else
+        yield if block_given?
+      end
+    end
+
+    alias_method :transaction, :synchronize
+
+    def destroy
+      if respond_to?(:_destroy) && @using_shared_memory
+        _destroy
+      else
+        super
+      end
+    end
+
+    private
+
+    def shared?
+      @using_shared_memory
+    end
+
+    def acquire_memory_object(name, data_layout, permissions)
+      return @using_shared_memory = false unless Semian.semaphores_enabled? && respond_to?(:_acquire)
+
+      byte_size = data_layout.inject(0) { |sum, type| sum + ::Semian::SysVSharedMemory.sizeof(type) }
+      raise TypeError.new("Given data layout is 0 bytes: #{data_layout.inspect}") if byte_size <= 0
+      # Calls C layer to acquire/create a memory block, calling #bind_initialize_memory_callback in the process, see below
+      _acquire(name, byte_size, permissions)
+      @using_shared_memory = true
+    end
+
+    def bind_initialize_memory_callback
+      # Concrete classes must implement this in a subclass in C to bind a callback function of type
+      # void (*initialize_memory)(size_t byte_size, void *dest, void *prev_data, size_t prev_data_byte_size);
+      # to location ptr->initialize_memory, where ptr is a semian_shm_object*
+      # It is called when memory needs to be initialized or resized, possibly using previous memory
+      raise NotImplementedError
+    end
+  end
+end

lib/semian/sysv_sliding_window.rb

@@ -0,0 +1,12 @@
+module Semian
+  module SysV
+    class SlidingWindow < Semian::Simple::SlidingWindow #:nodoc:
+      include SysVSharedMemory
+
+      def initialize(max_size:, name:, permissions:)
+        data_layout = [:int, :int] + [:long] * max_size
+        super(max_size: max_size) unless acquire_memory_object(name, data_layout, permissions)
+      end
+    end
+  end
+end

lib/semian/sysv_state.rb

@@ -0,0 +1,59 @@
+require 'forwardable'
+
+module Semian
+  module SysV
+    class State < Semian::Simple::State #:nodoc:
+      include SysVSharedMemory
+      extend Forwardable
+
+      def_delegators :@integer, :semid, :shmid, :synchronize, :transaction,
+                     :shared?, :acquire_memory_object, :bind_initialize_memory_callback
+      private :shared?, :acquire_memory_object, :bind_initialize_memory_callback
+
+      def initialize(name:, permissions:)
+        @integer = Semian::SysV::Integer.new(name: name, permissions: permissions)
+        initialize_lookup
+      end
+
+      def open
+        self.value = :open
+      end
+
+      def close
+        self.value = :closed
+      end
+
+      def half_open
+        self.value = :half_open
+      end
+
+      def reset
+        close
+      end
+
+      def destroy
+        reset
+        @integer.destroy
+      end
+
+      def value
+        @num_to_sym.fetch(@integer.value) { raise ArgumentError }
+      end
+
+      private
+
+      def value=(sym)
+        @integer.value = @sym_to_num.fetch(sym) { raise ArgumentError }
+      end
+
+      def initialize_lookup
+        # Assume symbol_list[0] is mapped to 0
+        # Cannot just use #object_id since #object_id for symbols is different in every run
+        # For now, implement a C-style enum type backed by integers
+
+        @sym_to_num = {closed: 0, open: 1, half_open: 2}
+        @num_to_sym = @sym_to_num.invert
+      end
+    end
+  end
+end

test/simple_state_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class TestSimpleEnum < MiniTest::Unit::TestCase
+class TestSimpleState < MiniTest::Unit::TestCase
   CLASS = ::Semian::Simple::State
 
   def setup

test/sysv_integer_test.rb

@@ -0,0 +1,16 @@
+require 'test_helper'
+
+class TestSysVInteger < MiniTest::Unit::TestCase
+  CLASS = ::Semian::SysV::Integer
+
+  def setup
+    @integer = CLASS.new(name: 'TestSysVInteger', permissions: 0660)
+    @integer.reset
+  end
+
+  def teardown
+    @integer.destroy
+  end
+
+  include TestSimpleInteger::IntegerTestCases
+end

test/sysv_sliding_window_test.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+class TestSysVSlidingWindow < MiniTest::Unit::TestCase
+  CLASS = ::Semian::SysV::SlidingWindow
+
+  def setup
+    @sliding_window = CLASS.new(max_size: 6,
+                                name: 'TestSysVSlidingWindow',
+                                permissions: 0660)
+    @sliding_window.clear
+  end
+
+  def teardown
+    @sliding_window.destroy
+  end
+
+  include TestSimpleSlidingWindow::SlidingWindowTestCases
+
+  private
+
+  include TestSimpleSlidingWindow::SlidingWindowUtilityMethods
+end

test/sysv_state_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+class TestSysVState < MiniTest::Unit::TestCase
+  CLASS = ::Semian::SysV::State
+
+  def setup
+    @state = CLASS.new(name: 'TestSysVState',
+                       permissions: 0660)
+    @state.reset
+  end
+
+  def teardown
+    @state.destroy
+  end
+
+  include TestSimpleState::StateTestCases
+
+  def test_will_throw_error_when_invalid_symbol_given
+    # May occur if underlying integer gets into bad state
+    integer = @state.instance_eval "@integer"
+    integer.value = 100
+    assert_raises ArgumentError do
+      @state.value
+    end
+    assert_raises ArgumentError do
+      @state.open?
+    end
+    assert_raises ArgumentError do
+      @state.half_open?
+    end
+    assert_raises ArgumentError do
+      @state.closed?
+    end
+  end
+end