redis-single-file 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6bf43bb784d2365093662b00e3ebc71844803636a685c03d5d8b6d31922e188
-  data.tar.gz: 273fc20ad00f05d559c19423bb8ab267bcd63d0c3b3b103049e342e9bba14630
+  metadata.gz: edb75c9168f41403d71f413fcae1133c4bfc6bff978af32daf40d64c6ab51da0
+  data.tar.gz: 68ec43819a06ebdd69da4ac9a64c67b9c6591ef2f7fcb204883a73f833ccf6d5
 SHA512:
-  metadata.gz: 1542f984beb11a1024fc21e05f9e3e68954d95c05ad51208582db251d80d385bff609ba6bf836694996d6b0c0200f5836d9dc827b2e8f9c0b0167fba23bcd8f6
-  data.tar.gz: c5ee9aba31008d6708bed29864b8deb8b783668c2f7c9d11013035cc741701afb9759f457bb92f5b7c1a03238be3beeae1ec007949408df8618b9a8c0e93433a
+  metadata.gz: d9cef25d4361c94bfcb034a7dea4db8f20cfc36f0515fca827432c38b6a240db9c485af71acac6d9548536f61110ec60d7240f51ac492256c11cffa4c0d0c12f
+  data.tar.gz: 6a330862b3565e93bd6113bbc9cd9b7f04f3efc1f78e2268e14b4ee832e1b820fe8cd8588f607f4726cee1b0c3379aaae0af81667e341e74d5f537804537e503

data/.rubocop.yml

@@ -40,4 +40,4 @@ RSpec/MultipleExpectations:
 
 # Example has too many lines. [8/5]
 RSpec/ExampleLength:
-  Max: 10
+  Max: 20

data/benchmark.rb

@@ -3,8 +3,10 @@
 require 'benchmark/ips'
 require 'redis_single_file'
 
-scenario_1_semaphore = RedisSingleFile.new(name: :scenario1)
-scenario_2_semaphore = RedisSingleFile.new(name: :scenario2)
+PORT = ENV['WORKFLOW_PORT'] || 6379
+
+scenario_1_semaphore = RedisSingleFile.new(name: :scenario1, port: PORT)
+scenario_2_semaphore = RedisSingleFile.new(name: :scenario2, port: PORT)
 
 Benchmark.ips do |x|
   x.report('synchronize') do
@@ -18,18 +20,18 @@ Benchmark.ips do |x|
   x.report('threaded (10x)') do
     threads = 10.times.map do
       Thread.new do
-        scenario_3_semaphore = RedisSingleFile.new(name: :scenario3)
+        scenario_3_semaphore = RedisSingleFile.new(name: :scenario3, port: PORT)
         scenario_3_semaphore.synchronize { nil }
       end
     end
 
-    threads.each { _1.join(0.05) } while threads.any?(&:alive?)
+    threads.each { _1.join(0.2) } 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 = RedisSingleFile.new(name: :scenario4, port: PORT)
         scenario_4_semaphore.synchronize { nil }
       end
     end

data/lib/redis_single_file/cluster_client_builder.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RedisSingleFile
+  #
+  # This class is a cluster client builder that performs automatic cluster
+  # detection and redis client conversion. All params from the original
+  # non-cluster client will be transfered to the new cluster-enabled client
+  # when building the new client.
+  #
+  # @author lifeBCE
+  #
+  # @return [self] the custer_client instance
+  class ClusterClientBuilder
+    class << self
+      #
+      # Delegates class method calls to instance method
+      #
+      # @param [...] params passes directly to constructor
+      # @return [Redis::Cluster] redis cluster instance
+      def call(...) = new(...).call
+    end
+    #
+    # @note redis:
+    #   Standard redis client instance for a clustered environment. The
+    #   cluster information will be extracted from this client when creating
+    #   the new cluster-enabled client so must responsd to cluster commands
+    #   and have an enabled cluster configured.
+    #
+    # @return [self] cluster client builder instance
+    def initialize(redis:)
+      @redis = redis
+    end
+
+    # Convert standard redis client to a cluster-enabled client. Client options
+    # are extracted from the original client and passed to the new client along
+    # with parsed nodes from original client's cluster configuration.
+    #
+    # @raise [ClusterDisabledError] if cluster not enabled
+    # @return [Redis::Cluster] redis cluster instance
+    def call
+      raise ClusterDisabledError, 'cluster not detected' unless cluster_enabled?
+
+      # use extracted client options with parsed nodes
+      Redis::Cluster.new(**client_options, nodes:)
+    end
+
+    private # ==================================================================
+
+    attr_reader :redis
+
+    def nodes
+      cluster_nodes.filter_map do |node|
+        next unless node[:flags].include?('master')
+
+        "redis://#{node[:address].split('@').first}"
+      end
+    end
+
+    def cluster_enabled?
+      redis.info('cluster')['cluster_enabled'] == '1'
+    rescue Redis::CommandError
+      false # assume cluster mode is disabled
+    end
+
+    def cluster_nodes
+      cluster_info = redis.cluster('NODES')
+
+      cluster_info.split("\n").map do |line|
+        parts = line.split
+        master_id = parts[3] == '-' ? nil : parts[3]
+
+        {
+          id: parts[0],                 # Node ID
+          address: parts[1],            # IP:Port@bus-port
+          flags: parts[2].split(','),   # Flags (e.g., master, slave, fail, handshake)
+          master_id:,                   # Master node ID (if applicable)
+          ping_sent: parts[4].to_i,     # Milliseconds since last PING
+          pong_received: parts[5].to_i, # Milliseconds since last PONG
+          config_epoch: parts[6].to_i,  # Config epoch
+          link_state: parts[7],         # Link state (connected/disconnected)
+          slots: parts[8..]             # Assigned slots (if present)
+        }
+      end
+    end
+
+    def client_options
+      config = redis._client.config
+      params = %i[
+        db ssl host port path custom username password protocol
+        ssl_params read_timeout write_timeout connect_timeout
+      ]
+
+      params_hash = params.each.with_object({}) do |key, memo|
+        memo[key] = config.public_send(key)
+      end
+
+      params_hash.merge(url: config.server_url)
+    end
+  end
+end

data/lib/redis_single_file/semaphore.rb

@@ -82,7 +82,7 @@ module RedisSingleFile
     # @return [nil] redis blpop timeout
     def synchronize(timeout: 0, &)
       synchronize!(timeout:, &)
-    rescue QueueTimeout => _e
+    rescue QueueTimeoutError => _e
       nil
     end
 
@@ -91,13 +91,13 @@ module RedisSingleFile
     #
     # @param timeout [Integer] seconds for blpop to wait in queue
     # @yieldreturn [...] response from synchronized block execution
-    # @raise [QueueTimeout] redis blpop timeout
+    # @raise [QueueTimeoutError] 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:)
+        raise QueueTimeoutError unless redis.blpop(queue_key, timeout:)
 
         redis.multi do
           redis.persist(mutex_key) # unexpire during execution
@@ -131,7 +131,7 @@ module RedisSingleFile
     def unlock_queue
       with_retry_protection do
         redis.multi do
-          # queue next client execution
+          # queue next client execution if queue is empty
           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
@@ -139,8 +139,8 @@ module RedisSingleFile
       end
     end
 
-    def with_retry_protection
-      yield if block_given?
+    def with_retry_protection(&)
+      with_cluster_protection(&) if block_given?
     rescue Redis::ConnectionError => _e
       retry_count ||= 0
       retry_count  += 1
@@ -149,5 +149,25 @@ module RedisSingleFile
       sleep(retry_count) && retry if retry_count < 6
       raise # re-raise after all retries exhausted
     end
+
+    def with_cluster_protection
+      yield if block_given?
+    rescue Redis::CommandError => e
+      cmd = e.message.split.first
+
+      # redis cluster configured but client does not support
+      # MOVED 14403 127.0.0.1:30003 (redis://localhost:30001)
+      if cmd == 'MOVED'
+        retry_count ||= 0
+        retry_count  += 1
+
+        if retry_count < 2 # allow a single retry
+          @redis = ClusterClientBuilder.call(redis:)
+          retry # retry same command with new client
+        end
+      end
+
+      raise # cmd != MOVED or retries exhausted
+    end
   end
 end

data/lib/redis_single_file/version.rb

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

data/lib/redis_single_file.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 require 'redis'
+require 'redis-clustering'
 require 'singleton'
 
 require_relative 'redis_single_file/version'
 require_relative 'redis_single_file/configuration'
+require_relative 'redis_single_file/cluster_client_builder'
 require_relative 'redis_single_file/semaphore'
 
 #
@@ -22,13 +24,18 @@ module RedisSingleFile
   Mutex = Semaphore
 
   # internal blpop timeout exception class
-  QueueTimeout = Class.new(StandardError)
+  QueueTimeoutError = Class.new(StandardError)
+
+  # MOVED response received but no cluster configured
+  ClusterDisabledError = Class.new(StandardError)
 
   class << self
+    # @return [Configuration] singleton instance
     def configuration
       yield Configuration.instance if block_given?
     end
 
+    # @return [Semaphore] distributed locking instance
     def new(...) = Semaphore.new(...)
   end
 end

data/test.rb

@@ -9,7 +9,7 @@ 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 = RedisSingleFile.new(name: RUN_ID, port: 30001)
 #semaphore.synchronize!(timeout: 10) do
 #  puts "Hello World!"
 #  sleep 1
@@ -19,7 +19,7 @@ TIMEOUT    = ITERATIONS * WORK_LOAD
 
 #10.times.map do
 #  fork do
-#    semaphore = RedisSingleFile::Mutex.new(name: RUN_ID)
+#    semaphore = RedisSingleFile.new(name: RUN_ID)
 #    semaphore.synchronize!(timeout: TIMEOUT) do
 #      puts "Hello World!"
 #      sleep WORK_LOAD
@@ -31,24 +31,18 @@ TIMEOUT    = ITERATIONS * WORK_LOAD
 #
 #Process.waitall
 
-# exit
-
+#exit
 
-#while true do
 threads = ITERATIONS.times.map do
   thread = Thread.new do
-    semaphore = RedisSingleFile::Mutex.new(name: RUN_ID)
+    semaphore = RedisSingleFile.new(name: RUN_ID, port: 30001)
     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
+threads.each { _1.join(0.2) } while threads.any?(&:alive?)

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: redis-single-file
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - LifeBCE
 bindir: exe
 cert_chain: []
-date: 2025-02-04 00:00:00.000000000 Z
+date: 2025-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -23,6 +23,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 5.3.0
+- !ruby/object:Gem::Dependency
+  name: redis-clustering
+  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
@@ -38,6 +52,7 @@ files:
 - Rakefile
 - benchmark.rb
 - lib/redis_single_file.rb
+- lib/redis_single_file/cluster_client_builder.rb
 - lib/redis_single_file/configuration.rb
 - lib/redis_single_file/semaphore.rb
 - lib/redis_single_file/version.rb