redisbetween 0.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 749198c4742de0123a0226e37853bba82f50b7effb9ccb570b421ec1a78d68c3
+  data.tar.gz: 1eb3ac3e7f9c40b76154bee60091b6a13d01a4a2627f157014c8614cf2764040
+SHA512:
+  metadata.gz: 3e6cb4c970d63130e51191eb450de90078032d05e9086e888aed7da4f99597676eef5fa5a6c7bb8f7b5a0cfdf60b4d96ef06e4590d0ca572485252538408f96d
+  data.tar.gz: 601805fa28010afd16c3cb49859f268fcd4ce74cfb49cbec013d09f0b5990cebfe98a4cb74052d0214e5fdba87f15ea7b03e76915949566fe34101bf22594691

data/lib/redisbetween/version.rb

@@ -0,0 +1,3 @@
+module Redisbetween
+  VERSION = "0.2.2"
+end

data/lib/redisbetween.rb

@@ -0,0 +1,110 @@
+require 'redisbetween/version'
+require 'redis'
+require 'uri'
+require 'set'
+
+module Redisbetween
+  class Error < StandardError; end
+
+  PIPELINE_START_SIGNAL = '🔜'
+  PIPELINE_END_SIGNAL = '🔚'
+
+  module ClientPatch
+    attr_reader :redisbetween_enabled
+
+    def initialize(options = {})
+      @redisbetween_enabled = !!options[:convert_to_redisbetween_socket]
+      @handle_unsupported_redisbetween_command = options[:handle_unsupported_redisbetween_command]
+      if @redisbetween_enabled
+        @handle_unsupported_redisbetween_command ||= ->(cmd) { puts "redisbetween: unsupported #{cmd}" }
+      end
+
+      if redisbetween_enabled
+        if options[:url]
+          u = URI(options[:url])
+          if u.scheme != 'unix'
+            path = u.path.empty? ? nil : u.path.delete_prefix('/')
+            u.path = Redisbetween.socket_path(options[:convert_to_redisbetween_socket], u.host, u.port, path)
+            u.host = nil
+            u.port = nil
+            u.scheme = 'unix'
+            options[:url] = u.to_s
+          end
+        elsif options[:host] && options[:port] && options[:scheme] != 'unix'
+          path = Redisbetween.socket_path(options[:convert_to_redisbetween_socket], options[:host], options[:port])
+          [:port, :host, :scheme].each { |k| options[k] = nil }
+          options[:url] = "unix:#{path}"
+        end
+      end
+      super(options)
+    end
+
+    UNSUPPORTED_COMMANDS = Set.new([
+      :auth,
+      :blpop,
+      :brpop,
+      :bzpopmax,
+      :bzpopmin,
+      :select,
+      :wait,
+      :xread,
+      :xreadgroup,
+    ])
+
+    def process(commands)
+      @handle_unsupported_redisbetween_command&.call("multi without a block") if commands == [[:multi]]
+
+      logging(commands) do
+        ensure_connected do
+          wrap = commands.size > 1 && redisbetween_enabled
+
+          _rb_wrapped_write(wrap) do
+            commands.each do |command|
+              if UNSUPPORTED_COMMANDS.member?(command.first)
+                @handle_unsupported_redisbetween_command&.call(command.first.to_s)
+              end
+              if command_map[command.first]
+                command = command.dup
+                command[0] = command_map[command.first]
+              end
+
+              write(command)
+            end
+          end
+
+          _rb_wrapped_read(wrap) do
+            yield if block_given?
+          end
+        end
+      end
+    end
+
+    def _rb_wrapped_write(wrap)
+      write([:get, PIPELINE_START_SIGNAL]) if wrap
+      yield
+      write([:get, PIPELINE_END_SIGNAL]) if wrap
+    end
+
+    # the proxy sends back nil values as placeholders for the signals, so discard them
+    def _rb_wrapped_read(wrap)
+      read if wrap
+      res = yield
+      read if wrap
+      res
+    end
+  end
+
+  def self.socket_path(option, host, port, path = nil)
+    if option.respond_to?(:call)
+      option.call(host, port, path)
+    else
+      default_socket_path(host, port, path)
+    end
+  end
+
+  def self.default_socket_path(host, port, path = nil)
+    ['/var/tmp/redisbetween', host, port, path].compact.join('-') + '.sock'
+  end
+end
+
+Redis::Client.prepend(Redisbetween::ClientPatch)

data/spec/redisbetween_spec.rb

@@ -0,0 +1,205 @@
+RSpec.describe Redisbetween do
+  def test_logger(stream, level = Logger::DEBUG)
+    logger = Logger.new(stream)
+    logger.level = level
+    logger.formatter = proc { |_, _, _, msg| msg.sub("[Redis]", "").strip + "\n" }
+    logger
+  end
+
+  def redis_host
+    ENV['REDIS_HOST'] || '127.0.0.1'
+  end
+
+  def redis_url(port, db = nil)
+    out = "redis://#{redis_host}:#{port}"
+    out += "/#{db}" if db
+    out
+  end
+
+  def redis_socket(port)
+    "unix:/var/tmp/redisbetween-#{redis_host}-#{port}.sock"
+  end
+
+  def redis_client(cluster:, port:, **opts)
+    opts = cluster ? opts.merge(cluster: [redis_url(port)]) : opts.merge(url: redis_url(port))
+    Redis.new(opts)
+  end
+
+  it "has a version number" do
+    expect(Redisbetween::VERSION).not_to be nil
+  end
+  
+  describe '#convert_to_redisbetween_socket' do
+    it 'should allow passing a proc' do
+      path = Redisbetween.socket_path(->(host, port, path) { [host, port, path].join('-') }, "h", "p", "p")
+      expect(path).to eq("h-p-p")
+    end
+
+    it 'should default to /var/tmp' do
+      path = Redisbetween.socket_path(true, "h", "p", "p")
+      expect(path).to eq("/var/tmp/redisbetween-h-p-p.sock")
+    end
+
+    it 'should omit the path if not given' do
+      path = Redisbetween.socket_path(true, "h", "p")
+      expect(path).to eq("/var/tmp/redisbetween-h-p.sock")
+    end
+  end
+  
+  describe Redisbetween::ClientPatch do
+    it 'should point the client to a socket when given a url' do
+      client = Redis.new(url: redis_url(7006), convert_to_redisbetween_socket: true)
+      client.get "hi"
+      expect(client._client.options[:url]).to eq(redis_socket(7006))
+    end
+
+    it 'should point the cluster to a socket when given a url' do
+      client = Redis.new(cluster: [redis_url(7000)], convert_to_redisbetween_socket: true)
+      client._client.connection_info.map { |l| l[:location] }.each do |loc|
+        expect(loc).to match(/\/var\/tmp\/redisbetween-\d+\.\d+\.\d+\.\d+-\d+.sock/)
+      end
+    end
+
+    it 'should point the client to a socket when given host and port' do
+      client = Redis.new(host: redis_host, port: 1234, convert_to_redisbetween_socket: true)
+      expect(client._client.options[:url]).to eq(redis_socket(1234))
+    end
+
+    it 'should not mess with the url when not enabled' do
+      client = Redis.new(url: redis_url(7006, 10))
+      expect(client._client.options[:url]).to eq(redis_url(7006, 10))
+    end
+
+    [
+      [false, 7006],
+      [true, 7000],
+    ].each do |(cluster, port)|
+      context "with cluster #{cluster}, port #{port}" do
+        it 'should prepend and append the signal messages to all pipelines when enabled' do
+          stream = StringIO.new
+          client = redis_client(cluster: cluster, port: port, convert_to_redisbetween_socket: true, logger: test_logger(stream))
+          res = client.pipelined do
+            client.set("hi", 1)
+            client.get("hi")
+            client.set("yes", "maybe")
+            client.get("yes")
+          end
+          expect(res).to eq(%w[OK 1 OK maybe])
+          expect(stream.string).to include(<<~LOG
+            command=SET args="hi" "1"
+            command=GET args="hi"
+            command=SET args="yes" "maybe"
+            command=GET args="yes"
+          LOG
+          )
+        end
+
+        it 'should correctly process transactions with no cross slot keys' do
+          stream = StringIO.new
+          client = redis_client(cluster: cluster, port: port, convert_to_redisbetween_socket: true, logger: test_logger(stream))
+          res = client.multi do
+            client.set("{1}hi", 1)
+            client.get("{1}hi")
+            client.set("{1}yes", "maybe")
+            client.get("{1}yes")
+          end
+          expect(res).to eq(%w[OK 1 OK maybe])
+          expect(stream.string).to include(<<~LOG
+            command=MULTI args=
+            command=SET args="{1}hi" "1"
+            command=GET args="{1}hi"
+            command=SET args="{1}yes" "maybe"
+            command=GET args="{1}yes"
+            command=EXEC args=
+          LOG
+          )
+        end
+
+        it 'should not prepend or append the signal messages to any pipelines when not enabled' do
+          stream = StringIO.new
+          client = redis_client(cluster: cluster, port: port, logger: test_logger(stream))
+          res = client.pipelined do
+            client.set("hi", 1)
+            client.get("hi")
+            client.set("yes", "maybe")
+            client.get("yes")
+          end
+          expect(res).to eq(%w[OK 1 OK maybe])
+          expect(stream.string).to include(<<~LOG
+            command=SET args="hi" "1"
+            command=GET args="hi"
+            command=SET args="yes" "maybe"
+            command=GET args="yes"
+          LOG
+          )
+        end
+
+        it 'should not prepend or append the signal messages to multis when not enabled' do
+          stream = StringIO.new
+          client = redis_client(cluster: cluster, port: port, logger: test_logger(stream))
+          res = client.multi do
+            client.set("{1}hi", 1)
+            client.get("{1}hi")
+            client.set("{1}yes", "maybe")
+            client.get("{1}yes")
+          end
+          expect(res).to eq(%w[OK 1 OK maybe])
+          expect(stream.string).to include(<<~LOG
+            command=MULTI args=
+            command=SET args="{1}hi" "1"
+            command=GET args="{1}hi"
+            command=SET args="{1}yes" "maybe"
+            command=GET args="{1}yes"
+            command=EXEC args=
+          LOG
+          )
+        end
+      end
+    end
+
+    describe :handle_unsupported_redisbetween_command do
+      it 'should raise on unsupported commands when set to :raise' do
+        client = Redis.new(
+          url: redis_url(7006, 10),
+          handle_unsupported_redisbetween_command: ->(_cmd) { raise "hi" }
+        )
+        expect { client.select(2) }.to raise_error("hi")
+      end
+
+      it 'standalone: should call the given proc' do
+        stream = StringIO.new
+        logger = test_logger(stream)
+        client = Redis.new(
+          url: redis_url(7006, 10),
+          handle_unsupported_redisbetween_command: ->(cmd) { logger.warn("hi #{cmd}") }
+        )
+        client.select(2)
+        expect(stream.string).to include("hi select")
+      end
+
+      it 'cluster: should call the given proc' do
+        stream = StringIO.new
+        logger = test_logger(stream)
+        client = Redis.new(
+          cluster: [redis_url(7000)],
+          handle_unsupported_redisbetween_command: ->(cmd) { logger.warn(cmd) }
+        )
+        client.wait(1, 1)
+        expect(stream.string).to include("wait")
+      end
+
+      it 'should not mess with unsupported commands when not enabled' do
+        client = Redis.new(url: redis_url(7006, 10))
+        expect(client.select(2)).to eq("OK")
+      end
+
+      it 'should disallow multi without a block' do
+        client = Redis.new(
+          url: redis_url(7006, 10),
+          handle_unsupported_redisbetween_command: ->(cmd) { raise cmd }
+        )
+        expect { client.multi }.to raise_error("multi without a block")
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require "bundler/setup"
+require "redisbetween"
+require 'logger'
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: redisbetween
+version: !ruby/object:Gem::Version
+  version: 0.2.2
+platform: ruby
+authors:
+- Jordan Sitkin
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-06-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Client patch for the ruby redis driver to support redisbetween
+email:
+- jordan.sitkin@coinbase.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/redisbetween.rb
+- lib/redisbetween/version.rb
+- spec/redisbetween_spec.rb
+- spec/spec_helper.rb
+homepage:
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: redisbetween client gem
+test_files: []