async-redis 0.8.1 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c61c1f4d04e59d7a09f58429a04438e674d7839bc6d6411b3fc33668d4068c4b
-  data.tar.gz: f13579f444972e6b5a7d1388f37d20d74978e867130b5cdad303e829905a6ca6
+  metadata.gz: 97fe8ed81d0096bd994cbbd3511fc3acb7c0c4629cfafdac47e5c237137083f1
+  data.tar.gz: c8a5b6a33efb6de45dc7cc2154b694fbd9337a14c485f85f1693bfeabbcc0f79
 SHA512:
-  metadata.gz: 99b7e9bb4091f09a6b51a1216a44b69ebd63918df6755d447f327b69bdf148cbf91e7a1b1a5adbe75ccff93f36be93cdf0d5034bed624743fcac23524d285df7
-  data.tar.gz: f9afbc599da80472df731cb370c77422184c3a41a4ab0efd0df638fad31f9a68fa7cde775d7451826cf781c1d29e9c86d3d27c0a94a6b1605b121dd33dddd13f
+  metadata.gz: ad448e4900402ef3e974a247c27a6a8fa5bf65d47fda67b46260830ecfb76a185c86a03ff0c38cd18ae1d628a7ce332d6952e26704d357f3858458fe593fb49d
+  data.tar.gz: 83535dc337e792808e6e3033864e393cb075a5d709bd5a8c507577d8b792f0600388f98cd28997c891102c36dc79062c6327004359f51c4677b50bab42eced8a

data/lib/async/redis/client.rb

@@ -10,7 +10,7 @@
 require_relative 'context/pipeline'
 require_relative 'context/transaction'
 require_relative 'context/subscribe'
-require_relative 'protocol/resp2'
+require_relative 'endpoint'
 
 require 'io/endpoint/host_endpoint'
 require 'async/pool/controller'
@@ -23,14 +23,10 @@ module Async
 		# Legacy.
 		ServerError = ::Protocol::Redis::ServerError
 		
-		def self.local_endpoint(port: 6379)
-			::IO::Endpoint.tcp('localhost', port)
-		end
-		
 		class Client
 			include ::Protocol::Redis::Methods
 			
-			def initialize(endpoint = Redis.local_endpoint, protocol: Protocol::RESP2, **options)
+			def initialize(endpoint = Endpoint.local, protocol: endpoint.protocol, **options)
 				@endpoint = endpoint
 				@protocol = protocol
 				

data/lib/async/redis/context/pipeline.rb

@@ -2,7 +2,7 @@
 
 # Released under the MIT License.
 # Copyright, 2019, by David Ortiz.
-# Copyright, 2019-2023, by Samuel Williams.
+# Copyright, 2019-2024, by Samuel Williams.
 # Copyright, 2022, by Tim Willard.
 
 require_relative 'generic'
@@ -22,8 +22,8 @@ module Async
 					end
 					
 					# This method just accumulates the commands and their params.
-					def call(command, *arguments)
-						@pipeline.call(command, *arguments)
+					def call(...)
+						@pipeline.call(...)
 						
 						@pipeline.flush(1)
 						
@@ -46,6 +46,15 @@ module Async
 					end
 				end
 				
+				def collect
+					if block_given?
+						flush
+						yield
+					end
+					
+					@count.times.map{read_response}
+				end
+				
 				def sync
 					@sync ||= Sync.new(self)
 				end
@@ -73,15 +82,9 @@ module Async
 					end
 				end
 				
-				def collect
-					yield
-					
-					@count.times.map{read_response}
-				end
-				
 				def close
 					flush
-			  ensure
+				ensure
 					super
 				end
 			end

data/lib/async/redis/endpoint.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require 'io/endpoint'
+require 'io/endpoint/host_endpoint'
+require 'io/endpoint/ssl_endpoint'
+
+require_relative 'protocol/resp2'
+require_relative 'protocol/authenticated'
+require_relative 'protocol/selected'
+
+module Async
+	module Redis
+		def self.local_endpoint(**options)
+			Endpoint.local(**options)
+		end
+		
+		# Represents a way to connect to a remote Redis server.
+		class Endpoint < ::IO::Endpoint::Generic
+			LOCALHOST = URI.parse("redis://localhost").freeze
+			
+			def self.local(**options)
+				self.new(LOCALHOST, **options)
+			end	
+			
+			SCHEMES = {
+				'redis' => URI::Generic,
+				'rediss' => URI::Generic,
+			}
+			
+			def self.parse(string, endpoint = nil, **options)
+				url = URI.parse(string).normalize
+				
+				return self.new(url, endpoint, **options)
+			end
+			
+			# Construct an endpoint with a specified scheme, hostname, optional path, and options.
+			#
+			# @parameter scheme [String] The scheme to use, e.g. "redis" or "rediss".
+			# @parameter hostname [String] The hostname to connect to (or bind to).
+			# @parameter *options [Hash] Additional options, passed to {#initialize}.
+			def self.for(scheme, hostname, credentials: nil, port: nil, database: nil, **options)
+				uri_klass = SCHEMES.fetch(scheme.downcase) do
+					raise ArgumentError, "Unsupported scheme: #{scheme.inspect}"
+				end
+				
+				if database
+					path = "/#{database}"
+				end
+				
+				self.new(
+					uri_klass.new(scheme, credentials&.join(":"), hostname, port, nil, path, nil, nil, nil).normalize,
+					**options
+				)
+			end
+			
+			# Coerce the given object into an endpoint.
+			# @parameter url [String | Endpoint] The URL or endpoint to convert.
+			def self.[](object)
+				if object.is_a?(self)
+					return object
+				else
+					self.parse(object.to_s)
+				end
+			end
+			
+			# Create a new endpoint.
+			#
+			# @parameter url [URI] The URL to connect to.
+			# @parameter endpoint [Endpoint] The underlying endpoint to use.
+			# @parameter scheme [String] The scheme to use, e.g. "redis" or "rediss".
+			# @parameter hostname [String] The hostname to connect to (or bind to), overrides the URL hostname (used for SNI).
+			# @parameter port [Integer] The port to bind to, overrides the URL port.
+			def initialize(url, endpoint = nil, **options)
+				super(**options)
+				
+				raise ArgumentError, "URL must be absolute (include scheme, host): #{url}" unless url.absolute?
+				
+				@url = url
+				
+				if endpoint
+					@endpoint = self.build_endpoint(endpoint)
+				else
+					@endpoint = nil
+				end
+			end
+			
+			def to_url
+				url = @url.dup
+				
+				unless default_port?
+					url.port = self.port
+				end
+				
+				return url
+			end
+			
+			def to_s
+				"\#<#{self.class} #{self.to_url} #{@options}>"
+			end
+			
+			def inspect
+				"\#<#{self.class} #{self.to_url} #{@options.inspect}>"
+			end
+			
+			attr :url
+			
+			def address
+				endpoint.address
+			end
+			
+			def secure?
+				['rediss'].include?(self.scheme)
+			end
+			
+			def protocol
+				protocol = @options.fetch(:protocol, Protocol::RESP2)
+				
+				if credentials = self.credentials
+					protocol = Protocol::Authenticated.new(credentials, protocol)
+				end
+				
+				if database = self.database
+					protocol = Protocol::Selected.new(database, protocol)
+				end
+				
+				return protocol
+			end
+			
+			def default_port
+				6379
+			end
+			
+			def default_port?
+				port == default_port
+			end
+			
+			def port
+				@options[:port] || @url.port || default_port
+			end
+			
+			# The hostname is the server we are connecting to:
+			def hostname
+				@options[:hostname] || @url.hostname
+			end
+			
+			def scheme
+				@options[:scheme] || @url.scheme
+			end
+			
+			def database
+				@options[:database] || extract_database(@url.path)
+			end
+			
+			private def extract_database(path)
+				if path =~ /\/(\d+)$/
+					return $1.to_i
+				end
+			end
+			
+			def credentials
+				@options[:credentials] || extract_userinfo(@url.userinfo)
+			end
+			
+			private def extract_userinfo(userinfo)
+				if userinfo
+					credentials = userinfo.split(":").reject(&:empty?)
+					
+					if credentials.any?
+						return credentials
+					end
+				end
+			end
+			
+			def localhost?
+				@url.hostname =~ /^(.*?\.)?localhost\.?$/
+			end
+			
+			# We don't try to validate peer certificates when talking to localhost because they would always be self-signed.
+			def ssl_verify_mode
+				if self.localhost?
+					OpenSSL::SSL::VERIFY_NONE
+				else
+					OpenSSL::SSL::VERIFY_PEER
+				end
+			end
+			
+			def ssl_context
+				@options[:ssl_context] || OpenSSL::SSL::SSLContext.new.tap do |context|
+					context.set_params(
+						verify_mode: self.ssl_verify_mode
+					)
+				end
+			end
+			
+			def build_endpoint(endpoint = nil)
+				endpoint ||= tcp_endpoint
+				
+				if secure?
+					# Wrap it in SSL:
+					return ::IO::Endpoint::SSLEndpoint.new(endpoint,
+						ssl_context: self.ssl_context,
+						hostname: @url.hostname,
+						timeout: self.timeout,
+					)
+				end
+				
+				return endpoint
+			end
+			
+			def endpoint
+				@endpoint ||= build_endpoint
+			end
+			
+			def endpoint=(endpoint)
+				@endpoint = build_endpoint(endpoint)
+			end
+			
+			def bind(*arguments, &block)
+				endpoint.bind(*arguments, &block)
+			end
+			
+			def connect(&block)
+				endpoint.connect(&block)
+			end
+			
+			def each
+				return to_enum unless block_given?
+				
+				self.tcp_endpoint.each do |endpoint|
+					yield self.class.new(@url, endpoint, **@options)
+				end
+			end
+			
+			def key
+				[@url, @options]
+			end
+			
+			def eql? other
+				self.key.eql? other.key
+			end
+			
+			def hash
+				self.key.hash
+			end
+			
+			protected
+			
+			def tcp_options
+				options = @options.dup
+				
+				options.delete(:scheme)
+				options.delete(:port)
+				options.delete(:hostname)
+				options.delete(:ssl_context)
+				options.delete(:protocol)
+				
+				return options
+			end
+			
+			def tcp_endpoint
+				::IO::Endpoint.tcp(self.hostname, port, **tcp_options)
+			end
+		end
+	end
+end

data/lib/async/redis/protocol/authenticated.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require 'protocol/redis'
+
+module Async
+	module Redis
+		module Protocol
+			# Executes AUTH after the user has established a connection.
+			class Authenticated
+				# Authentication has failed for some reason.
+				class AuthenticationError < StandardError
+				end
+				
+				# Create a new authenticated protocol.
+				#
+				# @parameter credentials [Array] The credentials to use for authentication.
+				# @parameter protocol [Object] The delegated protocol for connecting.
+				def initialize(credentials, protocol = Async::Redis::Protocol::RESP2)
+					@credentials = credentials
+					@protocol = protocol
+				end
+				
+				attr :credentials
+				
+				# Create a new client and authenticate it.
+				def client(stream)
+					client = @protocol.client(stream)
+					
+					client.write_request(["AUTH", *@credentials])
+					response = client.read_response
+					
+					if response != "OK"
+						raise AuthenticationError, "Could not authenticate: #{response}"
+					end
+					
+					return client
+				end
+			end
+		end
+	end
+end

data/lib/async/redis/protocol/selected.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require 'protocol/redis'
+
+module Async
+	module Redis
+		module Protocol
+			# Executes AUTH after the user has established a connection.
+			class Selected
+				# Authentication has failed for some reason.
+				class SelectionError < StandardError
+				end
+				
+				# Create a new authenticated protocol.
+				#
+				# @parameter index [Integer] The database index to select.
+				# @parameter protocol [Object] The delegated protocol for connecting.
+				def initialize(index, protocol = Async::Redis::Protocol::RESP2)
+					@index = index
+					@protocol = protocol
+				end
+				
+				attr :index
+				
+				# Create a new client and authenticate it.
+				def client(stream)
+					client = @protocol.client(stream)
+					
+					client.write_request(["SELECT", @index])
+					response = client.read_response
+					
+					if response != "OK"
+						raise SelectionError, "Could not select database: #{response}"
+					end
+					
+					return client
+				end
+			end
+		end
+	end
+end

data/lib/async/redis/sentinels.rb

@@ -11,17 +11,18 @@ module Async
 		class SentinelsClient < Client
 			def initialize(master_name, sentinels, role = :master, protocol = Protocol::RESP2, **options)
 				@master_name = master_name
+				
 				@sentinel_endpoints = sentinels.map do |sentinel|
 					::IO::Endpoint.tcp(sentinel[:host], sentinel[:port])
 				end
+				
 				@role = role
-
 				@protocol = protocol
 				@pool = connect(**options)
 			end
-
+			
 			private
-
+			
 			# Override the parent method. The only difference is that this one needs
 			# to resolve the master/slave address.
 			def connect(**options)
@@ -29,66 +30,72 @@ module Async
 					endpoint = resolve_address
 					peer = endpoint.connect
 					stream = ::IO::Stream(peer)
-
+					
 					@protocol.client(stream)
 				end
 			end
-
+			
 			def resolve_address
-				address = case @role
-									when :master then resolve_master
-									when :slave then resolve_slave
-									else raise ArgumentError, "Unknown instance role #{@role}"
-									end
-
+				case @role
+				when :master
+					resolve_master
+				when :slave
+					resolve_slave
+				else
+					raise ArgumentError, "Unknown instance role #{@role}"
+				end => address
+				
 				address or raise RuntimeError, "Unable to fetch #{@role} via Sentinel."
 			end
-
+			
 			def resolve_master
 				@sentinel_endpoints.each do |sentinel_endpoint|
-					client = Client.new(sentinel_endpoint)
-
+					client = Client.new(sentinel_endpoint, protocol: @protocol)
+					
 					begin
 						address = client.call('sentinel', 'get-master-addr-by-name', @master_name)
 					rescue Errno::ECONNREFUSED
 						next
 					end
-
+					
 					return ::IO::Endpoint.tcp(address[0], address[1]) if address
 				end
-
+				
 				nil
 			end
-
+			
 			def resolve_slave
 				@sentinel_endpoints.each do |sentinel_endpoint|
-					client = Client.new(sentinel_endpoint)
-
+					client = Client.new(sentinel_endpoint, protocol: @protocol)
+					
 					begin
 						reply = client.call('sentinel', 'slaves', @master_name)
 					rescue Errno::ECONNREFUSED
 						next
 					end
-
+					
 					slaves = available_slaves(reply)
 					next if slaves.empty?
-
+					
 					slave = select_slave(slaves)
 					return ::IO::Endpoint.tcp(slave['ip'], slave['port'])
 				end
-
+				
 				nil
 			end
-
-			def available_slaves(slaves_cmd_reply)
+			
+			def available_slaves(reply)
 				# The reply is an array with the format: [field1, value1, field2,
 				# value2, etc.].
 				# When a slave is marked as down by the sentinel, the "flags" field
 				# (comma-separated array) contains the "s_down" value.
-				slaves_cmd_reply.map { |s| s.each_slice(2).to_h }
-						            .reject { |s| s.fetch('flags').split(',').include?('s_down') }
+				slaves = reply.map{|fields| fields.each_slice(2).to_h}
+				
+				slaves.reject do |slave|
+					slave['flags'].split(',').include?('s_down')
+				end
 			end
-
+			
 			def select_slave(available_slaves)
 				available_slaves.sample
 			end

data/lib/async/redis/version.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2018-2023, by Samuel Williams.
+# Copyright, 2018-2024, by Samuel Williams.
 
 module Async
 	module Redis
-		VERSION = "0.8.1"
+		VERSION = "0.9.0"
 	end
 end

data/readme.md

@@ -6,9 +6,9 @@ An asynchronous client for Redis including TLS. Support for streaming requests a
 
 ## Usage
 
-Please see the [project documentation](https://github.com/socketry/async-redis) for more details.
+Please see the [project documentation](https://socketry.github.io/async-redis/) for more details.
 
-  - [Getting Started](https://github.com/socketry/async-redisguides/getting-started/index) - This guide explains how to use the `async-redis` gem to connect to a Redis server and perform basic operations.
+  - [Getting Started](https://socketry.github.io/async-redis/guides/getting-started/index) - This guide explains how to use the `async-redis` gem to connect to a Redis server and perform basic operations.
 
 ## Contributing
 
@@ -22,8 +22,8 @@ We welcome contributions to this project.
 
 ### Developer Certificate of Origin
 
-This project uses the [Developer Certificate of Origin](https://developercertificate.org/). All contributors to this project must agree to this document to have their contributions accepted.
+In order to protect users of this project, we require all contributors to comply with the [Developer Certificate of Origin](https://developercertificate.org/). This ensures that all contributions are properly licensed and attributed.
 
-### Contributor Covenant
+### Community Guidelines
 
-This project is governed by the [Contributor Covenant](https://www.contributor-covenant.org/). All contributors and participants agree to abide by its terms.
+This project is best served by a collaborative and respectful environment. Treat each other professionally, respect differing viewpoints, and engage constructively. Harassment, discrimination, or harmful behavior is not tolerated. Communicate clearly, listen actively, and support one another. If any issues arise, please inform the project maintainers.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async-redis
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.9.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -48,28 +48,22 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2024-04-24 00:00:00.000000000 Z
+date: 2024-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.8'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '2.10'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.8'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '2.10'
 - !ruby/object:Gem::Dependency
   name: async-pool
   requirement: !ruby/object:Gem::Requirement
@@ -118,14 +112,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: '0.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: '0.9'
 description:
 email:
 executables: []
@@ -138,8 +132,11 @@ files:
 - lib/async/redis/context/pipeline.rb
 - lib/async/redis/context/subscribe.rb
 - lib/async/redis/context/transaction.rb
+- lib/async/redis/endpoint.rb
 - lib/async/redis/key.rb
+- lib/async/redis/protocol/authenticated.rb
 - lib/async/redis/protocol/resp2.rb
+- lib/async/redis/protocol/selected.rb
 - lib/async/redis/sentinels.rb
 - lib/async/redis/version.rb
 - license.md
@@ -148,6 +145,7 @@ homepage: https://github.com/socketry/async-redis
 licenses:
 - MIT
 metadata:
+  documentation_uri: https://socketry.github.io/async-redis/
   source_code_uri: https://github.com/socketry/async-redis.git
 post_install_message:
 rdoc_options: []
@@ -164,7 +162,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: A Redis client library.