event_store_client 1.4.9 → 2.0.0

data/lib/event_store_client/adapters/grpc/client.rb

@@ -1,136 +1,275 @@
 # frozen_string_literal: true
 
+# rubocop:disable Layout/LineLength, Metrics/ParameterLists
+
 module EventStoreClient
   module GRPC
     class Client
       include Configuration
-      # Appends given events to the stream
-      # @param [String] Stream name to append events to
-      # @param [Array](each: EventStoreClient::DeserializedEvent) list of events to publish
-      # @return Dry::Monads::Result::Success or Dry::Monads::Result::Failure
-      #
-      def append_to_stream(stream_name, events, options: {})
-        Commands::Streams::Append.new.call(
-          stream_name, events, options: options
-        )
-      end
 
-      # Softly deletes the given stream
-      # @param [String] Stream name to delete
-      # @param options [Hash] additional options to the request
-      # @return Dry::Monads::Result::Success or Dry::Monads::Result::Failure
-      #
-      def delete_stream(stream_name, options: {})
-        Commands::Streams::Delete.new.call(
-          stream_name, options: options
-        )
+      # @param stream_name [String]
+      # @param events_or_event [EventStoreClient::DeserializedEvent, Array<EventStoreClient::DeserializedEvent>]
+      # @param options [Hash]
+      # @option options [Integer] :expected_revision provide your own revision number
+      # @option options [String] :expected_revision provide one of next values: 'any', 'no_stream'
+      #   or 'stream_exists'
+      # @param credentials [Hash]
+      # @option credentials [String] :username override authentication username
+      # @option credentials [String] :password override authentication password
+      # @yield [EventStore::Client::Streams::AppendReq, EventStore::Client::Streams::AppendReq]
+      #   yields options and proposed message option right before sending the request. You can
+      #   extend it with your own options, not covered in the default implementation.
+      #   Example:
+      #     ```ruby
+      #     append_to_stream('some-stream', event) do |req_opts, proposed_msg_opts|
+      #       puts req_opts.options
+      #       puts proposed_msg_opts.proposed_message
+      #     end
+      #   ```
+      # @return [Dry::Monads::Result::Success, Dry::Monads::Result::Failure, Array<Dry::Monads::Result::Success, Dry::Monads::Result::Failure>]
+      #   Returns monads' Success/Failure in case whether request was performed.
+      def append_to_stream(stream_name, events_or_event, options: {}, credentials: {}, &blk)
+        if events_or_event.is_a?(Array)
+          Commands::Streams::AppendMultiple.new(**credentials).call(
+            stream_name, events_or_event, options: options
+          )
+        else
+          Commands::Streams::Append.new(**credentials).call(
+            stream_name, events_or_event, options: options, &blk
+          )
+        end
       end
 
-      # Completely removes the given stream
-      # @param [String] Stream name to delete
-      # @param options [Hash] additional options to the request
-      # @return Dry::Monads::Result::Success or Dry::Monads::Result::Failure
+      # @param stream_name [String]
+      # @param skip_deserialization [Boolean]
+      # @param skip_decryption [Boolean]
+      # @param options [Hash] request options
+      # @option options [String] :direction read direction - 'Forwards' or 'Backwards'
+      # @option options [Integer, Symbol] :from_revision. If number is provided - it is threaded
+      #   as starting revision number. Alternatively you can provide :start or :end value to
+      #   define a stream revision. **Use this option when stream name is a normal stream name**
+      # @option options [Hash, Symbol] :from_position. If hash is provided - you should supply
+      #   it with :commit_position and/or :prepare_position keys. Alternatively you can provide
+      #   :start or :end value to define a stream position. **Use this option when stream name
+      #   is "$all"**
+      # @option options [Integer] :max_count max number of events to return in one response
+      # @option options [Boolean] :resolve_link_tos When using projections to create new events you
+      #   can set whether the generated events are pointers to existing events. Setting this value
+      #   to true tells EventStoreDB to return the event as well as the event linking to it.
+      # @option options [Hash] :filter provide it to filter events when reading from $all. You can
+      #   either filter by stream name or filter by event type. Filtering can be done by using
+      #   Regexp or by a string.
+      #   Examples:
+      #     ```ruby
+      #     # Include events only from streams which names start from 'some-stream-1' and
+      #     # 'some-stream-2'
+      #     { filter: { stream_identifier: { prefix: ['some-stream-1', 'some-stream-2'] } } }
       #
-      def tombstone_stream(stream_name, options: {})
-        Commands::Streams::Tombstone.new.call(stream_name, options: options)
-      end
-
-      # Reads a page of events from the given stream
-      # @param [String] Stream name to read events from
-      # @param options [Hash] additional options to the request
-      # @return Dry::Monads::Result::Success with returned events or Dry::Monads::Result::Failure
+      #     # Include events only from streams which names end with digit
+      #     { filter: { stream_identifier: { regex: /\d$/.to_s } } }
       #
-      def read(stream_name, options: {})
-        Commands::Streams::Read.new.call(stream_name, options: options)
-      end
-
-      # Reads all events from the given stream
-      # @param [String] Stream name to read events from
-      # @param options [Hash] additional options to the request
-      # @return Dry::Monads::Result::Success with returned events or Dry::Monads::Result::Failure
+      #     # Include events which start from 'some-event-1' and 'some-event-2'
+      #     { filter: { event_type: { prefix: ['some-event-1', 'some-event-2'] } } }
       #
-      def read_all_from_stream(stream_name, options: {})
-        Commands::Streams::ReadAll.new.call(stream_name, options: options)
+      #     # Include events which names end with digit
+      #     { filter: { event_type: { regex: /\d$/.to_s } } }
+      #     ```
+      # @param credentials [Hash]
+      # @option credentials [String] :username override authentication username
+      # @option credentials [String] :password override authentication password
+      # @yield [EventStore::Client::Streams::ReadReq::Options] yields request options right
+      #   before sending the request. You can extend it with your own options, not covered in
+      #   the default implementation.
+      #   Example:
+      #     ```ruby
+      #     read('$all') do |opts|
+      #       opts.filter = EventStore::Client::Streams::ReadReq::Options::FilterOptions.new(
+      #         { stream_identifier: { prefix: ['as'] }, count: EventStore::Client::Empty.new }
+      #       )
+      #     end
+      #   ```
+      # @return [Dry::Monads::Success, Dry::Monads::Failure]
+      def read(stream_name, options: {}, skip_deserialization: config.skip_deserialization,
+               skip_decryption: config.skip_decryption, credentials: {}, &blk)
+        Commands::Streams::Read.new(**credentials).call(
+          stream_name,
+          options: options,
+          skip_deserialization: skip_deserialization,
+          skip_decryption: skip_decryption,
+          &blk
+        )
       end
 
-      # Creates the subscription for the given stream
-      # @param [EventStoreClient::Subscription] subscription to observe
-      # @param options [Hash] additional options to the request
-      # @return Dry::Monads::Result::Success or Dry::Monads::Result::Failure
-      #
-      def subscribe_to_stream(subscription, options: {})
-        join_streams(subscription.name, subscription.observed_streams)
-        Commands::PersistentSubscriptions::Create.new.call(
-          subscription.stream,
-          subscription.name,
-          options: options
+      # @see {#read} for available params
+      # @return [Enumerator] enumerator will yield Dry::Monads::Success or Dry::Monads::Failure on
+      #   each iteration
+      def read_paginated(stream_name, options: {}, credentials: {},
+                         skip_deserialization: config.skip_deserialization,
+                         skip_decryption: config.skip_decryption, &blk)
+        Commands::Streams::ReadPaginated.new(**credentials).call(
+          stream_name,
+          options: options,
+          skip_deserialization: skip_deserialization,
+          skip_decryption: skip_decryption,
+          &blk
         )
       end
 
-      # Links given events with the given stream
-      # @param [String] Stream name to link events to
-      # @param [Array](each: EventStoreClient::DeserializedEvent) a list of events to link
-      # @param expected_version [Integer] expected number of events in the stream
-      # @return Dry::Monads::Result::Success or Dry::Monads::Result::Failure
-      #
-      def link_to(stream_name, events, options: {})
-        Commands::Streams::LinkTo.new.call(stream_name, events, options: options)
+      # Refs https://developers.eventstore.com/server/v5/streams.html#hard-delete
+      # @param stream_name [String]
+      # @param options [Hash]
+      # @option options [Integer, String] :expected_revision provide your own revision number.
+      #   Alternatively you can provide one of next values: 'any', 'no_stream' or 'stream_exists'.
+      # @param credentials [Hash]
+      # @option credentials [String] :username override authentication username
+      # @option credentials [String] :password override authentication password
+      # @yield [EventStore::Client::Streams::TombstoneReq::Options] yields request options right
+      #   before sending the request. You can override them in your own way.
+      #   Example:
+      #     ```ruby
+      #     delete_stream('stream_name') do |opts|
+      #       opts.stream_identifier.stream_name = 'overridden-stream-name'
+      #     end
+      #     ```
+      # @return [Dry::Monads::Success, Dry::Monads::Failure]
+      def hard_delete_stream(stream_name, options: {}, credentials: {}, &blk)
+        Commands::Streams::HardDelete.new(**credentials).call(stream_name, options: options, &blk)
       end
 
-      # Runs the persistent subscription indeinitely
-      # @param [EventStoreClient::Subscription] subscription to observe
-      # @param options [Hash] additional options to the request
-      # @return - Nothing, it is a blocking operation, yields the given block with event instead
-      #
-      def listen(subscription, options: {})
-        consume_feed(subscription, options: options) do |event|
-          begin
-            yield event if block_given?
-          rescue StandardError => e
-            config.error_handler&.call(e)
-          end
-        end
+      # Refs https://developers.eventstore.com/server/v5/streams.html#soft-delete-and-truncatebefore
+      # @param stream_name [String]
+      # @param options [Hash]
+      # @option options [Integer, String] :expected_revision provide your own revision number.
+      #   Alternatively you can provide one of next values: 'any', 'no_stream' or 'stream_exists'.
+      # @param credentials [Hash]
+      # @option credentials [String] :username override authentication username
+      # @option credentials [String] :password override authentication password
+      # @yield [EventStore::Client::Streams::DeleteReq::Options] yields request options right
+      #   before sending the request. You can override them in your own way.
+      #   Example:
+      #     ```ruby
+      #     delete_stream('stream_name') do |opts|
+      #       opts.stream_identifier.stream_name = 'overridden-stream-name'
+      #     end
+      #     ```
+      # @return [Dry::Monads::Success, Dry::Monads::Failure]
+      def delete_stream(stream_name, options: {}, credentials: {}, &blk)
+        Commands::Streams::Delete.new(**credentials).call(stream_name, options: options, &blk)
       end
 
-      # Subscribe to a stream
-      # @param options [Hash] additional options to the request
-      # @return - Nothing, it is a blocking operation, yields the given block with event instead
+      # Subscribe to the given stream and listens for events. Note, that it will block execution of
+      #   current stack. If you want to do it asynchronous - consider putting it out of current
+      #   thread.
+      # @param stream_name [String]
+      # @param handler [#call] whenever new event arrives - #call method of your handler will be
+      #   called with the response passed into it
+      # @param skip_deserialization [Boolean]
+      # @param skip_decryption [Boolean]
+      # @param options [Hash] request options
+      # @option options [String] :direction read direction - 'Forwards' or 'Backwards'
+      # @option options [Integer, Symbol] :from_revision. If number is provided - it is threaded
+      #   as starting revision number. Alternatively you can provide :start or :end value to
+      #   define a stream revision. **Use this option when stream name is a normal stream name**
+      # @option options [Hash, Symbol] :from_position. If hash is provided - you should supply
+      #   it with :commit_position and/or :prepare_position keys. Alternatively you can provide
+      #   :start or :end value to define a stream position. **Use this option when stream name
+      #   is "$all"**
+      # @option options [Boolean] :resolve_link_tos When using projections to create new events you
+      #   can set whether the generated events are pointers to existing events. Setting this value
+      #   to true tells EventStoreDB to return the event as well as the event linking to it.
+      # @option options [Hash] :filter provide it to filter events when subscribing to $all. You can
+      #   either filter by stream name or filter by event type. Filtering can be done by using
+      #   Regexp or by a string.
+      #   Examples:
+      #     ```ruby
+      #     # Include events only from streams which names start from 'some-stream-1' and
+      #     # 'some-stream-2'
+      #     { filter: { stream_identifier: { prefix: ['some-stream-1', 'some-stream-2'] } } }
       #
-      def subscribe(options = {})
-        Commands::Streams::Subscribe.new.call(options) do |event|
-          yield event if block_given?
-        end
-      rescue StandardError => e
-        config.error_handler&.call(e)
-      end
-
-      private
-
-      # Joins multiple streams into the new one under the given name
-      # @param [String] Name of the stream containing the ones to join
-      # @param [Array] (each: String) list of streams to join together
-      # @return Dry::Monads::Result::Success or Dry::Monads::Result::Failure
+      #     # Include events only from streams which names end with digit
+      #     { filter: { stream_identifier: { regex: /\d$/.to_s } } }
+      #
+      #     # Include events which start from 'some-event-1' and 'some-event-2'
+      #     { filter: { event_type: { prefix: ['some-event-1', 'some-event-2'] } } }
       #
-      def join_streams(name, streams)
-        res = Commands::Projections::Create.new.call(name, streams)
-        return if res.success?
+      #     # Include events which names end with digit
+      #     { filter: { event_type: { regex: /\d$/.to_s } } }
+      #     ```
+      # @param credentials [Hash]
+      # @option credentials [String] :username override authentication username
+      # @option credentials [String] :password override authentication password
+      # @yield [EventStore::Client::Streams::ReadReq::Options] yields request options right
+      #   before sending the request. You can extend it with your own options, not covered in
+      #   the default implementation.
+      #   Example:
+      #     ```ruby
+      #     subscribe_to_stream('$all', handler: proc { |response| puts response }) do |opts|
+      #       opts.filter = EventStore::Client::Streams::ReadReq::Options::FilterOptions.new(
+      #         { stream_identifier: { prefix: ['as'] }, max: 100 }
+      #       )
+      #     end
+      #     ```
+      # @return [Dry::Monads::Success, Dry::Monads::Failure]
+      def subscribe_to_stream(stream_name, handler:, options: {}, credentials: {},
+                              skip_deserialization: config.skip_deserialization,
+                              skip_decryption: config.skip_decryption, &blk)
+        Commands::Streams::Subscribe.new(**credentials).call(
+          stream_name,
+          handler: handler,
+          options: options,
+          skip_deserialization: skip_deserialization,
+          skip_decryption: skip_decryption,
+          &blk
+        )
+      end
 
-        Commands::Projections::Update.new.call(name, streams)
+      # This method acts the same as #subscribe_to_stream with the only exception that it subscribes
+      # to $all stream
+      # @see #subscribe_to_stream
+      def subscribe_to_all(handler:, options: {}, credentials: {},
+                           skip_deserialization: config.skip_deserialization,
+                           skip_decryption: config.skip_decryption, &blk)
+        Commands::Streams::Subscribe.new(**credentials).call(
+          '$all',
+          handler: handler,
+          options: options,
+          skip_deserialization: skip_deserialization,
+          skip_decryption: skip_decryption,
+          &blk
+        )
       end
 
-      # @api private
-      # Consumes the new events from the subscription
-      # @param [EventStoreClient::Subscription] subscription to observe
-      # @param options [Hash] additional options to the request
-      # @return Dry::Monads::Result::Success or Dry::Monads::Result::Failure
-      #
-      def consume_feed(subscription, options: {})
-        Commands::PersistentSubscriptions::Read.new.call(
-          subscription.stream, subscription.name, options: options
-        ) do |event|
-          yield event if block_given?
+      # Links event from one stream into another stream. You can later access it by providing
+      # :resolve_link_tos option when reading from a stream. If you provide an event that does not
+      # present in EventStore database yet - its data will not be appended properly to the stream,
+      # thus, making it look as a malformed event.
+      # @see #append_to_stream for available params and returned value
+      def link_to(stream_name, events_or_event, options: {}, credentials: {}, &blk)
+        if events_or_event.is_a?(Array)
+          Commands::Streams::LinkToMultiple.new(**credentials).call(
+            stream_name,
+            events_or_event,
+            options: options,
+            &blk
+          )
+        else
+          Commands::Streams::LinkTo.new(**credentials).call(
+            stream_name,
+            events_or_event,
+            options: options,
+            &blk
+          )
         end
       end
+
+      # @param credentials [Hash]
+      # @option credentials [String] :username
+      # @option credentials [String] :password
+      # @return [Dry::Monads::Success, Dry::Monads::Failure]
+      def cluster_info(credentials: {})
+        Commands::Gossip::ClusterInfo.new(**credentials).call
+      end
     end
   end
 end
+# rubocop:enable Layout/LineLength, Metrics/ParameterLists

data/lib/event_store_client/adapters/grpc/cluster/gossip_discover.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+
+require 'event_store_client/adapters/grpc/generated/shared_pb'
+require 'event_store_client/adapters/grpc/generated/gossip_pb'
+require 'event_store_client/adapters/grpc/generated/gossip_services_pb'
+
+module EventStoreClient
+  module GRPC
+    module Cluster
+      class GossipDiscover
+        include Configuration
+
+        DiscoverError = Class.new(StandardError)
+
+        # Order is important - it plays role of states priority as well
+        READ_ONLY_STATES = %i[ReadOnlyReplica PreReadOnlyReplica ReadOnlyLeaderless].freeze
+        ALLOWED_NODE_STATES =
+          (%i[Leader Follower] + READ_ONLY_STATES).freeze
+
+        # @param nodes [Array<EventStoreClient::Connection::Url::Node>]
+        # @param failed_member [EventStoreClient::GRPC::Cluster::Member, nil]
+        # @return [EventStoreClient::GRPC::Cluster::Member]
+        # @raise [EventStoreClient::GRPC::Cluster::GossipDiscover::DiscoverError]
+        def call(nodes, failed_member:)
+          nodes = sort_nodes(nodes, failed_member)
+
+          attempts = config.eventstore_url.max_discover_attempts
+          attempts.times do
+            nodes.each do |node|
+              suitable_member = suitable_member_of_node(node)
+              next unless suitable_member
+
+              return suitable_member
+            end
+
+            sleep(config.eventstore_url.discover_interval / 1000.0)
+          end
+
+          raise DiscoverError, "Failed to discover suitable host after #{attempts} attempts."
+        end
+
+        private
+
+        # @return [Array<Symbol>]
+        def ordered_states
+          @ordered_states ||=
+            # Move preferred state to the first place
+            case config.eventstore_url.node_preference
+            when :Leader, :Follower
+              [config.eventstore_url.node_preference] +
+              (ALLOWED_NODE_STATES - [config.eventstore_url.node_preference])
+            else
+              READ_ONLY_STATES + (ALLOWED_NODE_STATES - READ_ONLY_STATES)
+            end
+        end
+
+        # @param node [EventStoreClient::Connection::Url::Node]
+        # @return [Array<EventStoreClient::GRPC::Cluster::Member>, nil]
+        def node_members(node)
+          connection = Connection.new(
+            host: node.host,
+            port: node.port,
+            timeout: config.eventstore_url.gossip_timeout
+          )
+          members =
+            connection.
+            call(EventStore::Client::Gossip::Gossip::Stub).
+            read(EventStore::Client::Empty.new).
+            members
+          members.map do |member|
+            Member.new(
+              host: member.http_end_point.address,
+              port: member.http_end_point.port,
+              state: member.state,
+              active: member.is_alive,
+              instance_id: Utils.uuid_to_str(member.instance_id)
+            )
+          end
+        rescue ::GRPC::BadStatus, Errno::ECONNREFUSED
+          config.logger&.debug("Failed to get cluster list from #{node.host}:#{node.port} node.")
+          nil
+        end
+
+        # Pick a suitable member based on its status and node preference
+        # @return [Array<EventStoreClient::GRPC::Cluster::Member>]
+        # @return [EventStoreClient::GRPC::Cluster::Member]
+        def detect_suitable_member(members)
+          members = members.select(&:active)
+          members = members.select { |member| ALLOWED_NODE_STATES.include?(member.state) }
+          members = members.sort_by { |member| ordered_states.index(member.state) }
+          members.first
+        end
+
+        # Put failed node to the end of the list
+        # @param nodes [Array<EventStoreClient::Connection::Url::Node>]
+        # @param failed_member [EventStoreClient::GRPC::Cluster::Member, nil]
+        # @return [Array<EventStoreClient::Connection::Url::Node>]
+        def sort_nodes(nodes, failed_member)
+          return nodes unless failed_member
+
+          nodes.sort_by do |node|
+            failed_member.host == node.host && failed_member.port == node.port ? 1 : 0
+          end
+        end
+
+        # Searches a suitable member among members of the given node
+        # @param node [EventStoreClient::Connection::Url::Node]
+        # @return [EventStoreClient::GRPC::Cluster::Member, nil]
+        def suitable_member_of_node(node)
+          config.logger&.debug(
+            "Starting to discover #{node.host}:#{node.port} node for candidates."
+          )
+          members = node_members(node)
+          return unless members
+
+          suitable_member = detect_suitable_member(members)
+          return unless suitable_member
+
+          config.logger&.debug(
+            "Found suitable member: #{suitable_member.host}:#{suitable_member.port} with " \
+            "role \"#{suitable_member.state}\"."
+          )
+          suitable_member
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/AbcSize, Metrics/MethodLength

data/lib/event_store_client/adapters/grpc/cluster/insecure_connection.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module EventStoreClient
+  module GRPC
+    module Cluster
+      class InsecureConnection < Connection
+        # @param stub_class GRPC request stub class. E.g. EventStore::Client::Gossip::Gossip::Stub
+        # @return instance of the given stub_class class
+        def call(stub_class)
+          config.logger&.debug('Using insecure connection.')
+          stub_class.new(
+            "#{host}:#{port}",
+            :this_channel_is_insecure,
+            channel_args: channel_args,
+            timeout: (timeout / 1000.0 if timeout)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/event_store_client/adapters/grpc/cluster/member.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module EventStoreClient
+  module GRPC
+    module Cluster
+      class Member
+        include Extensions::OptionsExtension
+
+        option(:host) # String
+        option(:port) # Integer
+        option(:active) # boolean
+        option(:instance_id) # string
+        option(:state) # symbol
+        option(:failed_endpoint) { false } # boolean
+      end
+    end
+  end
+end

data/lib/event_store_client/adapters/grpc/cluster/queryless_discover.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module EventStoreClient
+  module GRPC
+    module Cluster
+      class QuerylessDiscover
+        include Configuration
+
+        NoHostError = Class.new(StandardError)
+
+        # @param nodes [EventStoreClient::Connection::Url::Node]
+        # @return [EventStoreClient::GRPC::Cluster::Member]
+        def call(nodes)
+          raise NoHostError, 'No host setup' if nodes.empty?
+
+          Member.new(host: nodes.first.host, port: nodes.first.port).tap do |member|
+            config.logger&.debug(
+              "Picking #{member.host}:#{member.port} member without cluster discovery."
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/event_store_client/adapters/grpc/cluster/secure_connection.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module EventStoreClient
+  module GRPC
+    module Cluster
+      class SecureConnection < Connection
+        CertificateLookupError = Class.new(StandardError)
+
+        # @param stub_class GRPC request stub class. E.g. EventStore::Client::Gossip::Gossip::Stub
+        # @return instance of the given stub_class class
+        def call(stub_class)
+          config.logger&.debug("Using secure connection with credentials #{username}:#{password}.")
+          stub_class.new(
+            "#{host}:#{port}",
+            channel_credentials,
+            channel_args: channel_args,
+            timeout: (timeout / 1000.0 if timeout)
+          )
+        end
+
+        private
+
+        # @return [GRPC::Core::ChannelCredentials]
+        def channel_credentials
+          certificate =
+            if config.eventstore_url.tls_ca_file
+              config.logger&.debug('Picking certificate from tlsCAFile option.')
+              File.read(config.eventstore_url.tls_ca_file)
+            else
+              config.logger&.debug('Resolving certificate from current member.')
+              cert.to_s
+            end
+
+          ::GRPC::Core::ChannelCredentials.new(certificate)
+        end
+
+        # rubocop:disable Metrics/AbcSize
+
+        # @return [String, nil] returns the X.509 certificates the server presented
+        # @raise [EventStoreClient::GRPC::Cluster::SecureConnection::CertificateLookupError]
+        def cert
+          retries = 0
+
+          begin
+            Net::HTTP.start(host, port, use_ssl: true, verify_mode: verify_mode, &:peer_cert)
+          rescue SocketError => e
+            attempts = config.eventstore_url.ca_lookup_attempts
+            sleep config.eventstore_url.ca_lookup_interval / 1000.0
+            retries += 1
+            if retries <= attempts
+              config.logger&.debug("Failed to lookup certificate. Reason: #{e.class}. Retying.")
+              retry
+            end
+            raise(
+              CertificateLookupError,
+              "Failed to get X.509 certificate after #{attempts} attempts."
+            )
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        # @return [Integer] SSL verify mode
+        def verify_mode
+          return OpenSSL::SSL::VERIFY_PEER if config.eventstore_url.tls_verify_cert
+
+          OpenSSL::SSL::VERIFY_NONE
+        end
+      end
+    end
+  end
+end