redis-single-file 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b6bf43bb784d2365093662b00e3ebc71844803636a685c03d5d8b6d31922e188
+  data.tar.gz: 273fc20ad00f05d559c19423bb8ab267bcd63d0c3b3b103049e342e9bba14630
+SHA512:
+  metadata.gz: 1542f984beb11a1024fc21e05f9e3e68954d95c05ad51208582db251d80d385bff609ba6bf836694996d6b0c0200f5836d9dc827b2e8f9c0b0167fba23bcd8f6
+  data.tar.gz: c5ee9aba31008d6708bed29864b8deb8b783668c2f7c9d11013035cc741701afb9759f457bb92f5b7c1a03238be3beeae1ec007949408df8618b9a8c0e93433a

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,43 @@
+require:
+  - rubocop-rake
+  - rubocop-rspec
+  - rubocop-factory_bot
+
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.2
+  Exclude:
+    - 'test.rb'
+    - 'vendor/bundle/**/*'
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+# TODO: revisit this exclusion - (zero?)
+Style/NumericPredicate:
+  Exclude:
+    - lib/redis_single_file/semaphore.rb
+
+#
+# rspec stuff
+#
+
+# Prefer have_received for setting message expectations.
+#   Setup redis_mock as a spy using allow or instance_spy.
+RSpec/MessageSpies:
+  Enabled: false
+
+# Prefer allow over expect when configuring a response.
+RSpec/StubbedMock:
+  Enabled: false
+
+# Example has too many expectations [3/1].
+RSpec/MultipleExpectations:
+  Max: 6
+
+# Example has too many lines. [8/5]
+RSpec/ExampleLength:
+  Max: 10

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-01-31
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 LifeBCE
+
+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,200 @@
+[![Build Status](https://github.com/lifeBCE/redis-single-file/actions/workflows/build.yml/badge.svg)](https://github.com/lifeBCE/redis-single-file/actions/workflows/build.yml)
+[![RSpec Status](https://github.com/lifeBCE/redis-single-file/actions/workflows/rspec.yml/badge.svg)](https://github.com/lifeBCE/redis-single-file/actions/workflows/rspec.yml)
+[![CodeQL Status](https://github.com/lifeBCE/redis-single-file/actions/workflows/codeql.yml/badge.svg)](https://github.com/lifeBCE/redis-single-file/actions/workflows/codeql.yml)
+[![Rubocop Status](https://github.com/lifeBCE/redis-single-file/actions/workflows/rubocop.yml/badge.svg)](https://github.com/lifeBCE/redis-single-file/actions/workflows/rubocop.yml)
+[![Benchmark Status](https://github.com/lifeBCE/redis-single-file/actions/workflows/benchmark.yml/badge.svg)](https://github.com/lifeBCE/redis-single-file/actions/workflows/benchmark.yml)
+
+# Redis Single File - Distributed Execution Synchronization
+
+Redis single file is a queue-based implementation of a remote/shared semaphore
+for distributed execution synchronization. A distributed semaphore may be useful
+for synchronizing execution across numerous instances or between the application
+and background job workers.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'redis-single-file'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install redis-single-file
+
+## Configuration
+
+Configure redis single file via its configuration object.
+
+```ruby
+RedisSingleFile.configuration do |config|
+  # config.host = 'localhost'
+  # config.port = '6379'
+  # config.name = 'default'
+  # config.expire_in = 300
+end
+```
+
+## Usage Examples
+
+#### Default lock name and infinite blocking
+```ruby
+  semaphore = RedisSingleFile.new
+  semaphore.synchronize do
+    # synchronized logic defined here...
+  end
+```
+
+#### Named locks can provide exclusive synchronization
+```ruby
+   semaphore = RedisSingleFile.new(name: :user_cache_update)
+   semaphore.synchronize do
+      # synchronized logic defined here...
+   end
+```
+
+#### Prevent deadlocks by providing a timeout
+```ruby
+   semaphore = RedisSingleFile.new(name: :s3_file_upload)
+   semaphore.synchronize(timeout: 15) do
+      # synchronized logic defined here...
+   end
+```
+
+#### Use your own redis client instance
+```ruby
+   redis = Redis.new(...)
+   semaphore = RedisSingleFile.new(redis:)
+   semaphore.synchronize do
+      # synchronized logic defined here...
+   end
+```
+
+## Documentation
+
+### Distributed Queue Design
+
+The redis `blpop` command will attempt to pop (delete and return) a value from
+a queue but will block when no values are present in the queue. A timeout can
+be provided to prevent deadlock situations.
+
+To unblock (unlock) an instance, add/push an item to the queue. This is done
+one at a time to controll the serialization of the distrubuted execution. Redis
+selects the instance waiting the longest each time a new token is added.
+
+### Auto Expiration
+
+All redis keys are expired and automatically removed after a certain period
+but will be recreated again on the next use. Each new client should face one
+of two scenarios when entering synchronization.
+
+1. The mutex key is not set causing the client to create the keys and prime
+   the queue with its first token unlocking it for the first execution.
+
+2. The mutex key is already set so the client will skip the priming and enter
+   directly into the queue where it should immediately find a token left by
+   the last client upon completion or block waiting for the current client to
+   finish execution.
+
+### Considerations over redlock approach
+
+[Redlock](https://github.com/leandromoreira/redlock-rb) is the current standard and the official approach [suggested by redis themselves](https://redis.io/docs/latest/develop/use/patterns/distributed-locks/) but the design does have some complexities/drawbacks that some may wish to avoid. The following is a list of pros and cons of redis single file over redlock.
+
+<details>
+<summary><code>Pro:</code> Multi-master redis node configuration not required</summary>
+<br />
+<blockquote>
+The redlock design requires a multi-master redis node setup where each node is completely independent of the others (no replication). This would be uncommon in most standard application deployment environments so a seperate redis setup would be required just for the distributed lock management.
+<br /><br />
+Redis single file will work with your existing redis configuration so no need to maintain a seperate redis setup for the application of distributed semaphores.
+</blockquote>
+</details>
+
+<details>
+<summary><code>Pro:</code> No polling or waiting logic needed as redis does all the blocking</summary>
+<br />
+<blockquote>
+The redlock design requires the client to enter into a polling loop checking for the ability to execute its logic repeatedly. This approach is less efficient and requires quite a bit more logic to accomplish also making it more prone to error.
+<br /><br />
+Redis single file pushes much of this responsibility off to redis itself with the use of the <code>blpop</code> command. Redis will block on that call when no item is present in the queue and will allocate tokens to competing clients waiting their turn on a `first-come, first-served basis`.
+</blockquote>
+</details>
+
+<details>
+<summary><code>Pro:</code> Replication lag is not a concern with <code>blpop</code></summary>
+<br />
+<blockquote>
+The redlock design requires a multi-master setup given it utilizes read operations that could be delegated to a read replica in a standard clustered redis deployement. Redis replication is handled in an async manner so replication lag can hinder distributed synchronization when using read operations against a cluster utlizing replication.
+<br /><br />
+Redis single file is not susceptible to this limitation given that <code>blpop</code> is a write operation meaning it will always be handled by the master node eliminating concerns over replication lag.
+</blockquote>
+</details>
+
+<details>
+<summary><code>Con:</code> Redis cluster failover could disrupt currently queued clients</summary>
+<br />
+<blockquote>
+Redis single file does attempt to recognize a connection failure and proceeds in rejoining the queue when detected but there is still a small chance that a cluster failover could cause already queued clients to have issues.
+<br /><br />
+Redlock is not susceptible to this given the use of the multi-master deployment and absence of read-replicas so cluster failover (and recovery) is not a concern.
+</blockquote>
+</details>
+
+## Run Tests
+
+    $ bundle exec rspec
+
+```spec
+Finished in 0.00818 seconds (files took 0.09999 seconds to load)
+22 examples, 0 failures
+```
+
+## Benchmark
+
+    $ bundle exec ruby benchmark.rb
+
+```ruby
+ruby 3.2.0 (2022-12-25 revision a528908271) [arm64-darwin22]
+Warming up --------------------------------------
+         synchronize   434.000 i/100ms
+        synchronize!   434.000 i/100ms
+      threaded (10x)    29.000 i/100ms
+        forked (10x)     8.000 i/100ms
+Calculating -------------------------------------
+         synchronize      4.329k (± 1.9%) i/s  (230.98 μs/i) -     21.700k in   5.014460s
+        synchronize!      4.352k (± 0.3%) i/s  (229.79 μs/i) -     22.134k in   5.086272s
+      threaded (10x)    249.794 (±28.4%) i/s    (4.00 ms/i) -      1.073k in   5.058461s
+        forked (10x)     56.588 (± 3.5%) i/s   (17.67 ms/i) -    288.000 in   5.097885s
+
+Comparison:
+        synchronize!:     4351.8 i/s
+         synchronize:     4329.4 i/s - same-ish: difference falls within error
+      threaded (10x):      249.8 i/s - 17.42x  slower
+        forked (10x):       56.6 i/s - 76.90x  slower
+```
+
+## Disclaimer
+
+> [!WARNING]
+> Make sure you understand the limitations and reliability inherent in this implementation prior to using it in a production environment. No guarantees are made. Use at your own risk!
+
+## Inspiration
+
+Inspiration for this gem was taken from a number of existing projects. It would be beneficial for anyone interested to take a look at all 3.
+
+1. [Redlock](https://github.com/leandromoreira/redlock-rb)
+2. [redis-semaphore](https://github.com/dv/redis-semaphore)
+3. [redis-mutex](https://github.com/kenn/redis-mutex)
+
+## Contributing
+
+1. [Fork it](https://github.com/lifeBCE/redis-single-file/fork)
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/benchmark.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+require 'redis_single_file'
+
+scenario_1_semaphore = RedisSingleFile.new(name: :scenario1)
+scenario_2_semaphore = RedisSingleFile.new(name: :scenario2)
+
+Benchmark.ips do |x|
+  x.report('synchronize') do
+    scenario_1_semaphore.synchronize { nil }
+  end
+
+  x.report('synchronize!') do
+    scenario_2_semaphore.synchronize! { nil }
+  end
+
+  x.report('threaded (10x)') do
+    threads = 10.times.map do
+      Thread.new do
+        scenario_3_semaphore = RedisSingleFile.new(name: :scenario3)
+        scenario_3_semaphore.synchronize { nil }
+      end
+    end
+
+    threads.each { _1.join(0.05) } while threads.any?(&:alive?)
+  end
+
+  x.report('forked (10x)') do
+    10.times.each do
+      fork do
+        scenario_4_semaphore = RedisSingleFile.new(name: :scenario4)
+        scenario_4_semaphore.synchronize { nil }
+      end
+    end
+
+    Process.waitall
+  end
+
+  x.compare!
+end

data/lib/redis_single_file/configuration.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RedisSingleFile
+  #
+  # This class provides the ability to configure redis single file.
+  #
+  # @author lifeBCE
+  #
+  # @example RedisSingleFile configuration
+  #   RedisSingleFile.configuration do |config|
+  #     config.host = 'localhost'
+  #     config.port = '6379'
+  #     config.name = 'default'
+  #     config.expire_in = 300
+  #   end
+  #
+  # @return [self] the configuration instance
+  class Configuration
+    include Singleton
+
+    # configuration defaults when not provided
+    DEFAULT_HOST = 'localhost'
+    DEFAULT_PORT = '6379'
+    DEFAULT_NAME = 'default'
+    DEFAULT_EXPIRE_IN = 300 # 5 mins
+    DEFAULT_MUTEX_KEY = 'RedisSingleFile/Mutex/%s'
+    DEFAULT_QUEUE_KEY = 'RedisSingleFile/Queue/%s'
+
+    # class delegation methods to singleton instance
+    #
+    # Example:
+    #   Configuration.host => Configuration.instance.host
+    #   Configuration.port => Configuration.instance.port
+    #
+    class << self
+      %i[host port name expire_in mutex_key queue_key].each do |attr|
+        define_method(attr) { instance.send(attr) }
+      end
+    end
+
+    # writers used in config block to set new values
+    attr_writer :host, :port, :name, :expire_in
+
+    # @return [String] redis server hostname value
+    def host = @host || DEFAULT_HOST
+
+    # @return [String] redis server port value
+    def port = @port || DEFAULT_PORT
+
+    # @return [String] default queue name when omitted
+    def name = @name || DEFAULT_NAME
+
+    # @return [String] redis keys expiration value
+    def expire_in = @expire_in || DEFAULT_EXPIRE_IN
+
+    # @note This attr is not configurable
+    # @return [String] synchronization mutex key name
+    def mutex_key = @mutex_key || DEFAULT_MUTEX_KEY
+
+    # @note This attr is not configurable
+    # @return [String] synchronization queue key name
+    def queue_key = @queue_key || DEFAULT_QUEUE_KEY
+  end
+end

data/lib/redis_single_file/semaphore.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module RedisSingleFile
+  #
+  # This class acts as the main synchronization engine for distributed logic
+  # execution by utilizing the redis blpop command to facilitate a distributed
+  # synchronous queue.
+  #
+  # @author lifeBCE
+  #
+  # @attr redis [...] redis client instance
+  # @attr name [String] custom sync queue name
+  # @attr host [String] host for redis server
+  # @attr port [String] port for redis server
+  #
+  # @example Default lock name and infinite blocking
+  #   semaphore = RedisSingleFile::Semaphore.new
+  #   semaphore.synchronize do
+  #      # synchronized logic defined here...
+  #   end
+  #
+  # @example Named locks can provide exclusive synchronization
+  #   semaphore = RedisSingleFile::Semaphore.new(name: :user_cache_update)
+  #   semaphore.synchronize do
+  #      # synchronized logic defined here...
+  #   end
+  #
+  # @example Prevent deadlocks by providing a timeout
+  #   semaphore = RedisSingleFile::Semaphore.new(name: s3_file_upload)
+  #   semaphore.synchronize(timeout: 15) do
+  #      # synchronized logic defined here...
+  #   end
+  #
+  # @example Use your own redis client instance
+  #   redis = Redis.new(...)
+  #   semaphore = RedisSingleFile::Semaphore.new(redis:)
+  #   semaphore.synchronize do
+  #     # synchronized logic defined here...
+  #   end
+  #
+  # @return [self] the semaphore instance
+  class Semaphore
+    #
+    # @note redis:
+    #   Any more advanced configuration than host and port should be applied
+    #   to an instance outside of redis single file and passed in via this
+    #   attribute.
+    #
+    # @note name:
+    #   Distributed semaphores are coordinated by name. Each client that wishes
+    #   to synchronize a particular block should do so under the same name.
+    #
+    # #note host:
+    #   Each synchronized execution can be done on a different redis server
+    #   than globally configured. Passing a value for this attribute will
+    #   redirect to that host.
+    #
+    # @note port:
+    #   Each synchronized execution can be done on a different redis port
+    #   than globally configured. Passing a value for this attribute will
+    #   redirect to that port.
+    #
+    # @return [self] semaphore instance
+    def initialize(
+      redis: nil,               # provide your own redis instance
+      name: Configuration.name, # designate queue name per session
+      host: Configuration.host, # designate redis host per session
+      port: Configuration.port  # designate redis port per session
+    )
+      @redis = redis || Redis.new(host:, port:)
+
+      @mutex_val = name
+      @mutex_key = format(Configuration.mutex_key, @mutex_val)
+      @queue_key = format(Configuration.queue_key, @mutex_val)
+    end
+
+    # Queues up client and waits for turn to execute. Returns nil
+    # when queue wait time expires.
+    #
+    # @param timeout [Integer] seconds for client to wait in queue
+    # @yieldreturn [...] response from synchronized block execution
+    # @return [nil] redis blpop timeout
+    def synchronize(timeout: 0, &)
+      synchronize!(timeout:, &)
+    rescue QueueTimeout => _e
+      nil
+    end
+
+    # Queues up client and waits for turn to execute. Raise exception
+    # when queue wait time expires.
+    #
+    # @param timeout [Integer] seconds for blpop to wait in queue
+    # @yieldreturn [...] response from synchronized block execution
+    # @raise [QueueTimeout] redis blpop timeout
+    def synchronize!(timeout: 0)
+      return unless block_given?
+
+      with_retry_protection do
+        prime_queue unless redis.getset(mutex_key, mutex_val)
+        raise QueueTimeout unless redis.blpop(queue_key, timeout:)
+
+        redis.multi do
+          redis.persist(mutex_key) # unexpire during execution
+          redis.persist(queue_key) # unexpire during execution
+        end
+      end
+
+      yield
+    ensure
+      # always cycle the queue when exiting
+      unlock_queue if block_given?
+    end
+
+    private #===================================================================
+
+    attr_reader :redis, :mutex_key, :mutex_val, :queue_key
+
+    def expire_in
+      @expire_in ||= Configuration.expire_in
+    end
+
+    def prime_queue
+      with_retry_protection do
+        redis.multi do
+          redis.del(queue_key)        # remove existing queue
+          redis.lpush(queue_key, '1') # create and prime new queue
+        end
+      end
+    end
+
+    def unlock_queue
+      with_retry_protection do
+        redis.multi do
+          # queue next client execution
+          redis.lpush(queue_key, '1') if redis.llen(queue_key) == 0
+          redis.expire(mutex_key, expire_in) # set expiration for auto removal
+          redis.expire(queue_key, expire_in) # set expiration for auto removal
+        end
+      end
+    end
+
+    def with_retry_protection
+      yield if block_given?
+    rescue Redis::ConnectionError => _e
+      retry_count ||= 0
+      retry_count  += 1
+
+      # retry 5 times over 15 seconds then give up
+      sleep(retry_count) && retry if retry_count < 6
+      raise # re-raise after all retries exhausted
+    end
+  end
+end

data/lib/redis_single_file/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RedisSingleFile
+  VERSION = '0.1.1'
+end

data/lib/redis_single_file.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'redis'
+require 'singleton'
+
+require_relative 'redis_single_file/version'
+require_relative 'redis_single_file/configuration'
+require_relative 'redis_single_file/semaphore'
+
+#
+# RedisSingleFile - Distributed Execution Synchronization
+#
+# Redis single file is a queue-based implementation of a remote/shared
+# semaphore for distributed execution synchronization. A distributed
+# semaphore may be useful for synchronizing execution across numerous
+# instances or between the application and background job workers.
+#
+# @author lifeBCE
+#
+module RedisSingleFile
+  # alias semaphore as mutex
+  Mutex = Semaphore
+
+  # internal blpop timeout exception class
+  QueueTimeout = Class.new(StandardError)
+
+  class << self
+    def configuration
+      yield Configuration.instance if block_given?
+    end
+
+    def new(...) = Semaphore.new(...)
+  end
+end

data/sig/redis_single_file.rbs

@@ -0,0 +1,4 @@
+module RedisSingleFile
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/test.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+require 'pry'
+require 'redis_single_file'
+
+RUN_ID = 'same-same' #SecureRandom.uuid
+
+ITERATIONS = (ARGV[0] || 10).to_i
+WORK_LOAD  = (ARGV[1] || 1).to_i
+TIMEOUT    = ITERATIONS * WORK_LOAD
+
+#semaphore = RedisSingleFile::Mutex.new(name: RUN_ID)
+#semaphore.synchronize!(timeout: 10) do
+#  puts "Hello World!"
+#  sleep 1
+#end
+
+#exit
+
+#10.times.map do
+#  fork do
+#    semaphore = RedisSingleFile::Mutex.new(name: RUN_ID)
+#    semaphore.synchronize!(timeout: TIMEOUT) do
+#      puts "Hello World!"
+#      sleep WORK_LOAD
+#    end
+#  end
+#
+#  sleep 0.05
+#end
+#
+#Process.waitall
+
+# exit
+
+
+#while true do
+threads = ITERATIONS.times.map do
+  thread = Thread.new do
+    semaphore = RedisSingleFile::Mutex.new(name: RUN_ID)
+    semaphore.synchronize(timeout: TIMEOUT) do
+      puts "Hello World!"
+      sleep WORK_LOAD
+    end
+  end
+
+#  sleep 0.05
+  thread
+end
+
+while threads.any?(&:alive?) do
+  threads.each { _1.join(0.5) }
+end
+#end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: redis-single-file
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- LifeBCE
+bindir: exe
+cert_chain: []
+date: 2025-02-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.3.0
+description: Synchronize execution across numerous instances.
+email:
+- eric06@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmark.rb
+- lib/redis_single_file.rb
+- lib/redis_single_file/configuration.rb
+- lib/redis_single_file/semaphore.rb
+- lib/redis_single_file/version.rb
+- sig/redis_single_file.rbs
+- test.rb
+homepage: https://github.com/lifeBCE/redis-single-file
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/lifeBCE/redis-single-file
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.3
+specification_version: 4
+summary: Distributed semaphore implementation with redis.
+test_files: []