mini-safe-lib 0.0.1

data/redis-5.4.1/lib/redis/errors.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+class Redis
+  # Base error for all redis-rb errors.
+  class BaseError < StandardError
+  end
+
+  # Raised by the connection when a protocol error occurs.
+  class ProtocolError < BaseError
+    def initialize(reply_type)
+      super(<<-EOS.gsub(/(?:^|\n)\s*/, " "))
+        Got '#{reply_type}' as initial reply byte.
+        If you're in a forking environment, such as Unicorn, you need to
+        connect to Redis after forking.
+      EOS
+    end
+  end
+
+  # Raised by the client when command execution returns an error reply.
+  class CommandError < BaseError
+  end
+
+  class PermissionError < CommandError
+  end
+
+  class WrongTypeError < CommandError
+  end
+
+  class OutOfMemoryError < CommandError
+  end
+
+  if defined?(RedisClient::NoScriptError)
+    class NoScriptError < CommandError
+    end
+  end
+
+  # Base error for connection related errors.
+  class BaseConnectionError < BaseError
+  end
+
+  # Raised when connection to a Redis server cannot be made.
+  class CannotConnectError < BaseConnectionError
+  end
+
+  # Raised when connection to a Redis server is lost.
+  class ConnectionError < BaseConnectionError
+  end
+
+  # Raised when performing I/O times out.
+  class TimeoutError < BaseConnectionError
+  end
+
+  # Raised when the connection was inherited by a child process.
+  class InheritedError < BaseConnectionError
+  end
+
+  # Generally raised during Redis failover scenarios
+  class ReadOnlyError < BaseConnectionError
+  end
+
+  # Raised when client options are invalid.
+  class InvalidClientOptionError < BaseError
+  end
+
+  class SubscriptionError < BaseError
+  end
+end

data/redis-5.4.1/lib/redis/hash_ring.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'zlib'
+require 'digest/md5'
+
+class Redis
+  class HashRing
+    POINTS_PER_SERVER = 160 # this is the default in libmemcached
+
+    attr_reader :ring, :sorted_keys, :replicas, :nodes
+
+    # nodes is a list of objects that have a proper to_s representation.
+    # replicas indicates how many virtual points should be used pr. node,
+    # replicas are required to improve the distribution.
+    def initialize(nodes = [], replicas = POINTS_PER_SERVER)
+      @replicas = replicas
+      @ring = {}
+      @nodes = []
+      @sorted_keys = []
+      nodes.each do |node|
+        add_node(node)
+      end
+    end
+
+    # Adds a `node` to the hash ring (including a number of replicas).
+    def add_node(node)
+      @nodes << node
+      @replicas.times do |i|
+        key = server_hash_for("#{node.id}:#{i}")
+        @ring[key] = node
+        @sorted_keys << key
+      end
+      @sorted_keys.sort!
+    end
+
+    def remove_node(node)
+      @nodes.reject! { |n| n.id == node.id }
+      @replicas.times do |i|
+        key = server_hash_for("#{node.id}:#{i}")
+        @ring.delete(key)
+        @sorted_keys.reject! { |k| k == key }
+      end
+    end
+
+    # get the node in the hash ring for this key
+    def get_node(key)
+      hash = hash_for(key)
+      idx = binary_search(@sorted_keys, hash)
+      @ring[@sorted_keys[idx]]
+    end
+
+    def iter_nodes(key)
+      return [nil, nil] if @ring.empty?
+
+      crc = hash_for(key)
+      pos = binary_search(@sorted_keys, crc)
+      @ring.size.times do |n|
+        yield @ring[@sorted_keys[(pos + n) % @ring.size]]
+      end
+    end
+
+    private
+
+    def hash_for(key)
+      Zlib.crc32(key)
+    end
+
+    def server_hash_for(key)
+      Digest::MD5.digest(key).unpack1("L>")
+    end
+
+    # Find the closest index in HashRing with value <= the given value
+    def binary_search(ary, value)
+      upper = ary.size
+      lower = 0
+
+      while lower < upper
+        mid = (lower + upper) / 2
+        if ary[mid] > value
+          upper = mid
+        else
+          lower = mid + 1
+        end
+      end
+
+      upper - 1
+    end
+  end
+end

data/redis-5.4.1/lib/redis/pipeline.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+class Redis
+  class PipelinedConnection
+    attr_accessor :db
+
+    def initialize(pipeline, futures = [], exception: true)
+      @pipeline = pipeline
+      @futures = futures
+      @exception = exception
+    end
+
+    include Commands
+
+    def pipelined
+      yield self
+    end
+
+    def multi
+      transaction = MultiConnection.new(@pipeline, @futures)
+      send_command([:multi])
+      size = @futures.size
+      yield transaction
+      multi_future = MultiFuture.new(@futures[size..-1])
+      @pipeline.call_v([:exec]) do |result|
+        multi_future._set(result)
+      end
+      @futures << multi_future
+      multi_future
+    end
+
+    private
+
+    def synchronize
+      yield self
+    end
+
+    def send_command(command, &block)
+      future = Future.new(command, block, @exception)
+      @pipeline.call_v(command) do |result|
+        future._set(result)
+      end
+      @futures << future
+      future
+    end
+
+    def send_blocking_command(command, timeout, &block)
+      future = Future.new(command, block, @exception)
+      @pipeline.blocking_call_v(timeout, command) do |result|
+        future._set(result)
+      end
+      @futures << future
+      future
+    end
+  end
+
+  class MultiConnection < PipelinedConnection
+    def multi
+      raise Redis::BaseError, "Can't nest multi transaction"
+    end
+
+    private
+
+    # Blocking commands inside transaction behave like non-blocking.
+    # It shouldn't be done though.
+    # https://redis.io/commands/blpop/#blpop-inside-a-multi--exec-transaction
+    def send_blocking_command(command, _timeout, &block)
+      send_command(command, &block)
+    end
+  end
+
+  class FutureNotReady < RuntimeError
+    def initialize
+      super("Value will be available once the pipeline executes.")
+    end
+  end
+
+  class Future < BasicObject
+    FutureNotReady = ::Redis::FutureNotReady.new
+
+    def initialize(command, coerce, exception)
+      @command = command
+      @object = FutureNotReady
+      @coerce = coerce
+      @exception = exception
+    end
+
+    def inspect
+      "<Redis::Future #{@command.inspect}>"
+    end
+
+    def _set(object)
+      @object = @coerce ? @coerce.call(object) : object
+      value
+    end
+
+    def value
+      ::Kernel.raise(@object) if @exception && @object.is_a?(::StandardError)
+      @object
+    end
+
+    def is_a?(other)
+      self.class.ancestors.include?(other)
+    end
+
+    def class
+      Future
+    end
+  end
+
+  class MultiFuture < Future
+    def initialize(futures)
+      @futures = futures
+      @command = [:exec]
+      @object = FutureNotReady
+    end
+
+    def _set(replies)
+      @object = if replies
+        @futures.map.with_index do |future, index|
+          future._set(replies[index])
+          future.value
+        end
+      else
+        replies
+      end
+    end
+  end
+end

data/redis-5.4.1/lib/redis/subscribe.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+class Redis
+  class SubscribedClient
+    def initialize(client)
+      @client = client
+      @write_monitor = Monitor.new
+    end
+
+    def call_v(command)
+      @write_monitor.synchronize do
+        @client.call_v(command)
+      end
+    end
+
+    def subscribe(*channels, &block)
+      subscription("subscribe", "unsubscribe", channels, block)
+    end
+
+    def subscribe_with_timeout(timeout, *channels, &block)
+      subscription("subscribe", "unsubscribe", channels, block, timeout)
+    end
+
+    def psubscribe(*channels, &block)
+      subscription("psubscribe", "punsubscribe", channels, block)
+    end
+
+    def psubscribe_with_timeout(timeout, *channels, &block)
+      subscription("psubscribe", "punsubscribe", channels, block, timeout)
+    end
+
+    def ssubscribe(*channels, &block)
+      subscription("ssubscribe", "sunsubscribe", channels, block)
+    end
+
+    def ssubscribe_with_timeout(timeout, *channels, &block)
+      subscription("ssubscribe", "sunsubscribe", channels, block, timeout)
+    end
+
+    def unsubscribe(*channels)
+      call_v([:unsubscribe, *channels])
+    end
+
+    def punsubscribe(*channels)
+      call_v([:punsubscribe, *channels])
+    end
+
+    def sunsubscribe(*channels)
+      call_v([:sunsubscribe, *channels])
+    end
+
+    def close
+      @client.close
+    end
+
+    protected
+
+    def subscription(start, stop, channels, block, timeout = 0)
+      sub = Subscription.new(&block)
+
+      case start
+      when "ssubscribe" then channels.each { |c| call_v([start, c]) } # avoid cross-slot keys
+      else call_v([start, *channels])
+      end
+
+      while event = @client.next_event(timeout)
+        if event.is_a?(::RedisClient::CommandError)
+          raise Client::ERROR_MAPPING.fetch(event.class), event.message
+        end
+
+        type, *rest = event
+        if callback = sub.callbacks[type]
+          callback.call(*rest)
+        end
+        break if type == stop && rest.last == 0
+      end
+      # No need to unsubscribe here. The real client closes the connection
+      # whenever an exception is raised (see #ensure_connected).
+    end
+  end
+
+  class Subscription
+    attr :callbacks
+
+    def initialize
+      @callbacks = {}
+      yield(self)
+    end
+
+    def subscribe(&block)
+      @callbacks["subscribe"] = block
+    end
+
+    def unsubscribe(&block)
+      @callbacks["unsubscribe"] = block
+    end
+
+    def message(&block)
+      @callbacks["message"] = block
+    end
+
+    def psubscribe(&block)
+      @callbacks["psubscribe"] = block
+    end
+
+    def punsubscribe(&block)
+      @callbacks["punsubscribe"] = block
+    end
+
+    def pmessage(&block)
+      @callbacks["pmessage"] = block
+    end
+
+    def ssubscribe(&block)
+      @callbacks["ssubscribe"] = block
+    end
+
+    def sunsubscribe(&block)
+      @callbacks["sunsubscribe"] = block
+    end
+
+    def smessage(&block)
+      @callbacks["smessage"] = block
+    end
+  end
+end

data/redis-5.4.1/lib/redis/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Redis
+  VERSION = '5.4.1'
+end