semian 0.22.0.RC.1 → 0.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: afd87705b68966cef884eeeb1d5df4d052eeb86f2ff7d43c9499435795341461
-  data.tar.gz: 911a0772662b81e21dcb475c9b981ceb0fbaeadf26edbbca70ab8adbf5be4068
+  metadata.gz: 27fa3d35b047fbe54483763821e246e2ce6f1403d8b3354d5759c4bdf1b43b2b
+  data.tar.gz: '06303901cc95e293dee76cd712283a4a7db1536771133e83563c969a6f3598e5'
 SHA512:
-  metadata.gz: 8edb70d967cb15e12b919b3a7e6585f98848e2d569683d590d2d37e32eb57b65cd9f425931a3bf1575d91fc6c50e9d43901340cb33a34a671a585956b947514f
-  data.tar.gz: b880f4f52891cbc4fd3d97221053bddc741aa72a98b986826b8ca08454c73ccbe714cff311966387f40b83e2f48a6d2db4ddf23407ff275e55bfb8c1730b5673
+  metadata.gz: 31e47dcea63ba9fc861272d9b8c2d591eb5f2d0783b1d8cde667812ba1cc4307ea52b533f8dc3542d011fb98c770ed011ff3a84c3e1ee7239635b01c0717b1ad
+  data.tar.gz: e32d7f17f6d73c95418fe6b80f1dce3423271423d61c8acd1fda356dab02aac41c24637d9a0939d39e5ade7cb015a2e47182361ea5c9187b1b39d93d59058510

data/README.md

@@ -270,23 +270,23 @@ SEMIAN_PARAMETERS = {
   dynamic: true,
 }
 
-class CurrentSemianSubResource < ActiveSupport::Attributes
- attribute :name
+class CurrentSemianSubResource < ActiveSupport::CurrentAttributes
+ attribute :sub_name
 end
 
 Semian::NetHTTP.semian_configuration = proc do |host, port|
   name = "#{host}_#{port}"
-  if (sub_resource_name = CurrentSemianSubResource.name)
-    name << "_#{name}"
+  if (sub_resource_name = CurrentSemianSubResource.sub_name)
+    name << "_#{sub_resource_name}"
   end
   SEMIAN_PARAMETERS.merge(name: name)
 end
 
 # Two requests to example.com can use two different semian resources,
-# as long as `CurrentSemianSubResource.name` is set accordingly:
-# CurrentSemianSubResource.set(name: "sub_resource_1") { Net::HTTP.get_response(URI("http://example.com")) }
+# as long as `CurrentSemianSubResource.sub_name` is set accordingly:
+# CurrentSemianSubResource.set(sub_name: "sub_resource_1") { Net::HTTP.get_response(URI("http://example.com")) }
 # and:
-# CurrentSemianSubResource.set(name: "sub_resource_2") { Net::HTTP.get_response(URI("http://example.com")) }
+# CurrentSemianSubResource.set(sub_name: "sub_resource_2") { Net::HTTP.get_response(URI("http://example.com")) }
 ```
 
 For most purposes, `"#{host}_#{port}"` is a good default `name`. Custom `name` formats

data/ext/semian/resource.c

@@ -5,9 +5,6 @@ ID id_wait_time;
 ID id_timeout;
 int system_max_semaphore_count;
 
-static VALUE
-cleanup_semian_resource_acquire(VALUE self);
-
 static void
 check_tickets_xor_quota_arg(VALUE tickets, VALUE quota);
 
@@ -33,15 +30,11 @@ static const rb_data_type_t
 semian_resource_type;
 
 VALUE
-semian_resource_acquire(int argc, VALUE *argv, VALUE self)
+semian_resource_acquire_semaphore(int argc, VALUE *argv, VALUE self)
 {
   semian_resource_t *self_res = NULL;
   semian_resource_t res = { 0 };
 
-  if (!rb_block_given_p()) {
-    rb_raise(rb_eArgError, "acquire requires a block");
-  }
-
   TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, self_res);
   res = *self_res;
 
@@ -75,7 +68,19 @@ semian_resource_acquire(int argc, VALUE *argv, VALUE self)
     wait_time = LONG2NUM(res.wait_time);
   }
 
-  return rb_ensure(rb_yield, wait_time, cleanup_semian_resource_acquire, self);
+  return wait_time;
+}
+
+VALUE
+semian_resource_acquire(int argc, VALUE *argv, VALUE self)
+{
+  if (!rb_block_given_p()) {
+    rb_raise(rb_eArgError, "acquire requires a block");
+  }
+
+  VALUE wait_time = semian_resource_acquire_semaphore(argc, argv, self);
+
+  return rb_ensure(rb_yield, wait_time, semian_resource_release_semaphore, self);
 }
 
 VALUE
@@ -253,8 +258,8 @@ semian_resource_in_use(VALUE self)
   return Qtrue;
 }
 
-static VALUE
-cleanup_semian_resource_acquire(VALUE self)
+VALUE
+semian_resource_release_semaphore(VALUE self)
 {
   semian_resource_t *res = NULL;
   TypedData_Get_Struct(self, semian_resource_t, &semian_resource_type, res);

data/ext/semian/resource.h

@@ -33,10 +33,39 @@ semian_resource_initialize(VALUE self, VALUE id, VALUE tickets, VALUE quota, VAL
  *
  * If no timeout argument is provided, the default timeout passed to Semian.register will be used.
  *
+ * The given block is executed with the semaphore held and, when the block
+ * exits, the semaphore is automatically released.
  */
 VALUE
 semian_resource_acquire(int argc, VALUE *argv, VALUE self);
 
+/*
+ * call-seq:
+ *    resource.acquire_semaphore(timeout: default_timeout) -> wait_time
+ *
+ * Acquires a resource. The call will block for <code>timeout</code> seconds if a ticket
+ * is not available. If no ticket is available within the timeout period, Semian::TimeoutError
+ * will be raised.
+ *
+ * If no timeout argument is provided, the default timeout passed to Semian.register will be used.
+ *
+ * Note: The caller is responsible for releasing the semaphore when done by calling release_semaphore.
+ */
+VALUE
+semian_resource_acquire_semaphore(int argc, VALUE *argv, VALUE self);
+
+/*
+ * call-seq:
+ *    resource.release_semaphore() -> nil
+ *
+ * Releases a resource previously acquired with acquire_semaphore.
+ *
+ * Note: The method is NOT idempotent. The caller must ensure that the method is called exactly
+ * as many times as acquire_semaphore.
+ */
+VALUE
+semian_resource_release_semaphore(VALUE self);
+
 /*
  * call-seq:
  *   resource.destroy() -> true

data/ext/semian/semian.c

@@ -60,6 +60,8 @@ void Init_semian()
   rb_define_alloc_func(cResource, semian_resource_alloc);
   rb_define_method(cResource, "initialize_semaphore", semian_resource_initialize, 5);
   rb_define_method(cResource, "acquire", semian_resource_acquire, -1);
+  rb_define_method(cResource, "acquire_semaphore", semian_resource_acquire_semaphore, -1);
+  rb_define_method(cResource, "release_semaphore", semian_resource_release_semaphore, 0);
   rb_define_method(cResource, "count", semian_resource_count, 0);
   rb_define_method(cResource, "semid", semian_resource_id, 0);
   rb_define_method(cResource, "key", semian_resource_key, 0);

data/lib/semian/protected_resource.rb

@@ -4,7 +4,7 @@ module Semian
   class ProtectedResource
     extend Forwardable
 
-    def_delegators :@bulkhead, :destroy, :count, :semid, :tickets, :registered_workers
+    def_delegators :@bulkhead, :count, :semid, :tickets, :registered_workers
     def_delegators :@circuit_breaker,
       :reset,
       :mark_failed,

data/lib/semian/resource.rb

@@ -9,6 +9,12 @@ module Semian
       def instance(name, **kwargs)
         Semian.resources[name] ||= ProtectedResource.new(name, new(name, **kwargs), nil)
       end
+
+      private
+
+      def redefinable(method_name)
+        alias_method(method_name, method_name) # Silence method redefinition warnings
+      end
     end
 
     def initialize(name, tickets: nil, quota: nil, permissions: Semian.default_permissions, timeout: 0)
@@ -26,41 +32,48 @@ module Semian
       @name = name
     end
 
-    def reset_registered_workers!
+    redefinable def reset_registered_workers!
     end
 
-    def destroy
+    redefinable def destroy
     end
 
-    def unregister_worker
+    redefinable def unregister_worker
     end
 
-    def acquire(*)
+    redefinable def acquire(*)
       wait_time = 0
       yield wait_time
     end
 
-    def count
+    redefinable def acquire_semaphore
+      0
+    end
+
+    redefinable def release_semaphore
+    end
+
+    redefinable def count
       0
     end
 
-    def tickets
+    redefinable def tickets
       0
     end
 
-    def registered_workers
+    redefinable def registered_workers
       0
     end
 
-    def semid
+    redefinable def semid
       0
     end
 
-    def key
+    redefinable def key
       "0x00000000"
     end
 
-    def in_use?
+    redefinable def in_use?
       false
     end
   end

data/lib/semian/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Semian
-  VERSION = "0.22.0.RC.1"
+  VERSION = "0.22.0"
 end

data/lib/semian.rb

@@ -275,6 +275,21 @@ module Semian
     @thread_safe = thread_safe
   end
 
+  THREAD_BULKHEAD_DISABLED_VAR = :semian_bulkheads_disabled
+  private_constant(:THREAD_BULKHEAD_DISABLED_VAR)
+
+  def bulkheads_disabled_in_thread?(thread)
+    thread.thread_variable_get(THREAD_BULKHEAD_DISABLED_VAR)
+  end
+
+  def disable_bulkheads_for_thread(thread)
+    old_value = thread.thread_variable_get(THREAD_BULKHEAD_DISABLED_VAR)
+    thread.thread_variable_set(THREAD_BULKHEAD_DISABLED_VAR, true)
+    yield
+  ensure
+    thread.thread_variable_set(THREAD_BULKHEAD_DISABLED_VAR, old_value)
+  end
+
   private
 
   def create_circuit_breaker(name, **options)
@@ -318,7 +333,7 @@ module Semian
   end
 
   def create_bulkhead(name, **options)
-    return if ENV.key?("SEMIAN_BULKHEAD_DISABLED")
+    return if ENV.key?("SEMIAN_BULKHEAD_DISABLED") || bulkheads_disabled_in_thread?(Thread.current)
     return unless options.fetch(:bulkhead, true)
 
     permissions = options[:permissions] || default_permissions

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: semian
 version: !ruby/object:Gem::Version
-  version: 0.22.0.RC.1
+  version: 0.22.0
 platform: ruby
 authors:
 - Scott Francis
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-02 00:00:00.000000000 Z
+date: 2024-11-05 00:00:00.000000000 Z
 dependencies: []
 description: |2
       A Ruby C extention that is used to control access to shared resources
@@ -79,7 +79,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.14
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Bulkheading for Ruby with SysV semaphores