ory-client 1.22.87 → 1.22.88

data/vendor/bundle/ruby/3.2.0/gems/ethon-0.19.1/lib/ethon/multi/operations.rb

@@ -0,0 +1,472 @@
+# frozen_string_literal: true
+module Ethon
+  class Multi # :nodoc
+    # This module contains logic to run a multi.
+    module Operations
+      STARTED_MULTI = "ETHON: started MULTI"
+      PERFORMED_MULTI = "ETHON: performed MULTI"
+
+      # Return the multi handle. Inititialize multi handle,
+      # in case it didn't happened already.
+      #
+      # @example Return multi handle.
+      #   multi.handle
+      #
+      # @return [ FFI::Pointer ] The multi handle.
+      def handle
+        ensure_not_cleaned_up!
+
+        handle = @handle ||= begin
+          # Enforce fork safety before creating a handle for a Multi that was
+          # constructed before the fork but never touched.
+          Curl.check_pid!
+          pointer = Curl.multi_init
+          raise NoMemoryError, "curl_multi_init failed" if pointer.null?
+          Curl::MultiHandle.new(pointer)
+        end
+        handle.check_pid!
+        handle
+      end
+
+      # Clean up the multi.
+      #
+      # Removes all attached easy handles before freeing the native multi
+      # handle. Cleanup is terminal: the Multi cannot be used afterwards.
+      #
+      # @return [ nil ]
+      def cleanup
+        ensure_not_cleaned_up!
+        ensure_not_executing!
+        # A handle created before a fork must not be released in the child.
+        @handle.check_pid! if @handle
+
+        error = nil
+        begin
+          stack.dup.each do |easy|
+            begin
+              delete(easy)
+            rescue StandardError => e
+              # Keep detaching the other handles. A failed close or native
+              # detach must not strand every remaining handle on a Multi whose
+              # native handle is about to be freed.
+              error ||= e
+            end
+          end
+        ensure
+          # Cleanup is terminal. Release the native handle even when detaching
+          # one of the easy handles fails. Handles that could not be detached
+          # keep their multi ownership so they cannot be reused unsafely.
+          begin
+            @handle.free if @handle
+          ensure
+            stack.each do |easy|
+              begin
+                easy.finish_response_body_io
+              rescue StandardError
+                # Cleanup is best effort; keep tearing down the multi even if
+                # closing a streamed response fails.
+              end
+            end
+            stack.clear
+            @handle = nil
+            @running_count = nil
+            @assigned_sockets = nil
+            @procs = nil
+            @cleaned_up = true
+          end
+        end
+        raise error if error
+      end
+
+      # Initialize variables.
+      #
+      # @example Initialize variables.
+      #   multi.init_vars
+      #
+      # @return [ void ]
+      def init_vars
+        if @execution_mode == :perform
+          @timeout = ::FFI::MemoryPointer.new(:long)
+          @running_count_pointer = ::FFI::MemoryPointer.new(:int)
+          @msgs_left = ::FFI::MemoryPointer.new(:int)
+          @wait_strategy = if Curl.respond_to?(:multi_poll)
+            :poll
+          elsif Curl.respond_to?(:multi_wait)
+            :wait
+          else
+            :select
+          end
+
+          if @wait_strategy == :select
+            @timeval = Curl::Timeval.new
+            @fd_read = Curl::FDSet.new
+            @fd_write = Curl::FDSet.new
+            @fd_excep = Curl::FDSet.new
+            @max_fd = ::FFI::MemoryPointer.new(:int)
+          end
+        elsif @execution_mode == :socket_action
+          @running_count_pointer = FFI::MemoryPointer.new(:int)
+          @msgs_left = FFI::MemoryPointer.new(:int)
+        end
+      end
+
+      # Perform multi.
+      #
+      # @return [ nil ]
+      #
+      # @example Perform multi.
+      #   multi.perform
+      def perform
+        ensure_execution_mode(:perform)
+        ensure_not_cleaned_up!
+        ensure_not_executing!
+
+        Ethon.logger.debug(STARTED_MULTI)
+        @executing = true
+        begin
+          while ongoing?
+            run
+            timeout = get_timeout
+            next if timeout == 0
+            case @wait_strategy
+            when :poll
+              poll(timeout)
+            when :wait
+              wait(timeout)
+            else
+              reset_fds
+              set_fds(timeout)
+            end
+          end
+        ensure
+          @executing = false
+        end
+        Ethon.logger.debug(PERFORMED_MULTI)
+        nil
+      end
+
+      # Prepare multi.
+      #
+      # @return [ nil ]
+      #
+      # @example Prepare multi.
+      #   multi.prepare
+      #
+      # @deprecated It is no longer necessary to call prepare.
+      def prepare
+        Ethon.logger.warn(
+          "ETHON: It is no longer necessary to call "+
+          "Multi#prepare. It's going to be removed "+
+          "in future versions."
+        )
+      end
+
+      # Wait for activity on the multi's sockets.
+      #
+      # @example Wait up to one second.
+      #   multi.wait(1000)
+      #
+      # @param [ Integer ] timeout_ms Maximum time to wait in milliseconds.
+      #
+      # @return [ Integer ] Number of file descriptors with activity.
+      def wait(timeout_ms = 1000)
+        unless Curl.respond_to?(:multi_wait)
+          raise NotImplementedError, "curl_multi_wait is not supported by this libcurl"
+        end
+
+        numfds = (@numfds ||= ::FFI::MemoryPointer.new(:int))
+        code = Curl.multi_wait(handle, ::FFI::Pointer::NULL, 0, timeout_ms, numfds)
+        raise Errors::MultiWait.new(code) unless code == :ok
+
+        numfds.read_int
+      end
+
+      # Wait for activity using curl_multi_poll.
+      #
+      # @param [ Integer ] timeout_ms Maximum time to wait in milliseconds.
+      #
+      # @return [ Integer ] Number of file descriptors with activity.
+      def poll(timeout_ms = 1000)
+        unless Curl.respond_to?(:multi_poll)
+          raise NotImplementedError, "curl_multi_poll is not supported by this libcurl"
+        end
+
+        numfds = (@numfds ||= ::FFI::MemoryPointer.new(:int))
+        code = Curl.multi_poll(handle, ::FFI::Pointer::NULL, 0, timeout_ms, numfds)
+        raise Errors::MultiPoll.new(code) unless code == :ok
+
+        numfds.read_int
+      end
+
+      # Wake up a multi handle blocked in curl_multi_poll.
+      #
+      # @return [ Symbol ] The Curl multi return code.
+      def wakeup
+        unless Curl.respond_to?(:multi_wakeup)
+          raise NotImplementedError, "curl_multi_wakeup is not supported by this libcurl"
+        end
+
+        code = Curl.multi_wakeup(handle)
+        raise Errors::MultiWakeup.new(code) unless code == :ok
+
+        code
+      end
+
+      # Continue execution with an external IO loop.
+      #
+      # @example When no sockets are ready yet, or to begin.
+      #   multi.socket_action
+      #
+      # @example When a socket is readable
+      #   multi.socket_action(io_object, [:in])
+      #
+      # @example When a socket is readable and writable
+      #   multi.socket_action(io_object, [:in, :out])
+      #
+      # @param [ IO, Integer, nil ] io The socket to act on, or nil for the
+      #   timeout case.
+      # @param [ Integer, Symbol, Array ] readiness CURL_CSELECT_* readiness
+      #   bits, either as a number or as symbols such as :in and :out.
+      #
+      # @return [ Symbol ] The Curl.multi_socket_action return code.
+      def socket_action(io = nil, readiness = 0)
+        ensure_execution_mode(:socket_action)
+        ensure_not_cleaned_up!
+        ensure_not_executing!
+
+        fd = if io.nil?
+          ::Ethon::Curl::SOCKET_TIMEOUT
+        elsif io.is_a?(Integer)
+          io
+        else
+          io.fileno
+        end
+
+        @executing = true
+        begin
+          code = Curl.multi_socket_action(handle, fd, readiness, @running_count_pointer)
+          @running_count = @running_count_pointer.read_int
+
+          check
+
+          code
+        ensure
+          @executing = false
+        end
+      end
+
+      # Return whether the multi still contains requests or not.
+      #
+      # @example Return if ongoing.
+      #   multi.ongoing?
+      #
+      # @return [ Boolean ] True if ongoing, else false.
+      def ongoing?
+        stack.size > 0 || (running_count || 0) > 0
+      end
+
+      # Associate an arbitrary pointer with a socket in the multi handle.
+      #
+      # @param [ Integer, IO ] io The socket descriptor.
+      # @param [ FFI::Pointer, nil ] pointer The pointer to associate, or nil
+      #   to clear it.
+      #
+      # @return [ Symbol ] The Curl multi return code.
+      def assign(io, pointer)
+        unless pointer.nil? || pointer.is_a?(::FFI::Pointer)
+          raise Errors::InvalidValue.new(:assign, pointer)
+        end
+        # A freed wrapper still looks like a pointer, but libcurl would keep
+        # the dangling address.
+        if pointer.is_a?(Ethon::Curl::OwnedPointer)
+          pointer.check_pid!
+        end
+
+        socket = io.respond_to?(:fileno) ? io.fileno : io
+        # FFI would reject a non-integer descriptor with a TypeError instead
+        # of the error Ethon uses for invalid option values.
+        unless socket.is_a?(Integer)
+          raise Errors::InvalidValue.new(:assign, io)
+        end
+        code = Curl.multi_assign(handle, socket, pointer)
+        raise Errors::MultiAssign.new(code) unless code == :ok
+
+        # libcurl keeps the pointer until the socket is removed or assigned
+        # again, so keep it alive from Ruby as well.
+        if pointer.nil? || pointer.null?
+          (@assigned_sockets ||= {}).delete(socket)
+        else
+          (@assigned_sockets ||= {})[socket] = pointer
+        end
+
+        code
+      end
+
+      # Return the easy handles currently attached natively.
+      #
+      # @return [ Array<FFI::Pointer> ] Native easy handles.
+      def native_handles
+        unless Curl.respond_to?(:multi_get_handles)
+          raise NotImplementedError, "curl_multi_get_handles is not supported by this libcurl"
+        end
+
+        pointer = Curl.multi_get_handles(handle)
+        raise NoMemoryError, "curl_multi_get_handles failed" if pointer.null?
+
+        begin
+          handles = []
+          offset = 0
+          loop do
+            easy = pointer.get_pointer(offset)
+            break if easy.null?
+
+            handles << easy
+            offset += ::FFI.type_size(:pointer)
+          end
+          handles
+        ensure
+          Curl.free(pointer)
+        end
+      end
+
+      private
+
+      def ensure_not_cleaned_up!
+        return unless @cleaned_up
+        raise Errors::EthonError, "Multi has been cleaned up"
+      end
+
+      def ensure_not_executing!
+        return unless @executing
+
+        raise Errors::EthonError, "Multi is currently executing; wait for it to finish"
+      end
+
+      # Get timeout.
+      #
+      # @example Get timeout.
+      #   multi.get_timeout
+      #
+      # @return [ Integer ] The timeout.
+      #
+      # @raise [ Ethon::Errors::MultiTimeout ] If getting the timeout fails.
+      def get_timeout
+        code = Curl.multi_timeout(handle, @timeout)
+        raise Errors::MultiTimeout.new(code) unless code == :ok
+        timeout = @timeout.read_long
+        timeout = 1 if timeout < 0
+        timeout
+      end
+
+      # Reset file describtors.
+      #
+      # @example Reset fds.
+      #   multi.reset_fds
+      #
+      # @return [ void ]
+      def reset_fds
+        @fd_read.clear
+        @fd_write.clear
+        @fd_excep.clear
+      end
+
+      # Set fds.
+      #
+      # @example Set fds.
+      #   multi.set_fds
+      #
+      # @return [ void ]
+      #
+      # @raise [ Ethon::Errors::MultiFdset ] If setting the file descriptors fails.
+      # @raise [ Ethon::Errors::Select ] If select fails.
+      def set_fds(timeout)
+        code = Curl.multi_fdset(handle, @fd_read, @fd_write, @fd_excep, @max_fd)
+        raise Errors::MultiFdset.new(code) unless code == :ok
+        max_fd = @max_fd.read_int
+        if max_fd == -1
+          # No sockets are ready; wait for the timer instead of spinning.
+          sleep(timeout / 1000.0)
+        else
+          @timeval[:sec] = timeout / 1000
+          @timeval[:usec] = (timeout * 1000) % 1000000
+          loop do
+            code = Curl.select(max_fd + 1, @fd_read, @fd_write, @fd_excep, @timeval)
+            break unless code < 0 && ::FFI.errno == Errno::EINTR::Errno
+          end
+          raise Errors::Select.new(::FFI.errno) if code < 0
+        end
+      end
+
+      # Check.
+      #
+      # @example Check.
+      #   multi.check
+      #
+      # @return [ void ]
+      def check
+        msgs_left = (@msgs_left ||= ::FFI::MemoryPointer.new(:int))
+        while true
+          msg = Curl.multi_info_read(handle, msgs_left)
+          break if msg.null?
+          next if msg[:code] != :done
+          easy = stack.find{ |e| e.handle == msg[:easy_handle] }
+          # The handle may have been removed between the transfer finishing and
+          # the completion message being read.
+          next unless easy
+          easy.return_code = msg[:data][:code]
+          Ethon.logger.debug { "ETHON:         performed #{easy.log_inspect}" }
+          # delete finishes the transfer's response stream. A failed close or
+          # flush must not keep on_complete from running; raise it afterwards.
+          teardown_error = nil
+          begin
+            delete(easy)
+          rescue Exception => exception
+            # A handle that libcurl still owns must stay tracked for cleanup.
+            raise if stack.include?(easy)
+
+            teardown_error = exception
+          end
+          easy.complete
+          easy.raise_callback_error
+          raise teardown_error if teardown_error
+        end
+      end
+
+      # Run.
+      #
+      # @example Run
+      #   multi.run
+      #
+      # @return [ void ]
+      def run
+        running_count_pointer = (@running_count_pointer ||= ::FFI::MemoryPointer.new(:int))
+        begin code = trigger(running_count_pointer) end while code == :call_multi_perform
+        raise Errors::MultiPerform.new(code) unless code == :ok
+
+        check
+      end
+
+      # Trigger.
+      #
+      # @example Trigger.
+      #   multi.trigger
+      #
+      # @return [ Symbol ] The Curl.multi_perform return code.
+      def trigger(running_count_pointer)
+        code = Curl.multi_perform(handle, running_count_pointer)
+        @running_count = running_count_pointer.read_int
+        code
+      end
+
+      # Return number of running requests.
+      #
+      # @example Return count.
+      #   multi.running_count
+      #
+      # @return [ Integer ] Number running requests.
+      def running_count
+        @running_count
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.2.0/gems/ethon-0.19.1/lib/ethon/multi/options.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+module Ethon
+  class Multi
+
+    # This module contains the logic and knowledge about the
+    # available options on multi.
+    module Options
+
+      # Sets max_total_connections option.
+      #
+      # @example Set max_total_connections option.
+      #   multi.max_total_connections = $value
+      #
+      # @param [ Integer ] value The value to set.
+      #
+      # @return [ void ]
+      def max_total_connections=(value)
+        Curl.set_option(:max_total_connections, value_for(value, :int, :max_total_connections), handle, :multi)
+      end
+
+      # Sets max_concurrent_streams option.
+      #
+      # @example Set max_concurrent_streams option.
+      #   multi.max_concurrent_streams = $value
+      #
+      # @param [ Integer ] value The value to set.
+      #
+      # @return [ void ]
+      def max_concurrent_streams=(value)
+        Curl.set_option(:max_concurrent_streams, value_for(value, :int, :max_concurrent_streams), handle, :multi)
+      end
+
+      # Sets maxconnects option.
+      #
+      # An explicit value also disables the automatic sizing described in
+      # #raise_default_maxconnects.
+      #
+      # @example Set maxconnects option.
+      #   multi.maxconnects = $value
+      #
+      # @param [ Integer ] value The value to set.
+      #
+      # @return [ void ]
+      def maxconnects=(value)
+        @maxconnects_configured = true unless value.nil?
+        set_maxconnects(value)
+      end
+
+      # Sets max_host_connections option.
+      #
+      # @example Set max_host_connections option.
+      #   multi.max_host_connections = $value
+      #
+      # @param [ Integer ] value The value to set.
+      #
+      # @return [ void ]
+      def max_host_connections=(value)
+        Curl.set_option(:max_host_connections, value_for(value, :int, :max_host_connections), handle, :multi)
+      end
+
+      # Sets max_pipeline_length option.
+      #
+      # @example Set max_pipeline_length option.
+      #   multi.max_pipeline_length = $value
+      #
+      # @param [ Integer ] value The value to set.
+      #
+      # @return [ void ]
+      def max_pipeline_length=(value)
+        Curl.set_option(:max_pipeline_length, value_for(value, :int, :max_pipeline_length), handle, :multi)
+      end
+
+      # Sets content_length_penalty_size option.
+      #
+      # @example Set content_length_penalty_size option.
+      #   multi.content_length_penalty_size = $value
+      #
+      # @param [ Integer ] value The value to set.
+      #
+      # @return [ void ]
+      def content_length_penalty_size=(value)
+        Curl.set_option(:content_length_penalty_size, value, handle, :multi)
+      end
+
+      # Sets chunk_length_penalty_size option.
+      #
+      # @example Set chunk_length_penalty_size option.
+      #   multi.chunk_length_penalty_size = $value
+      #
+      # @param [ Integer ] value The value to set.
+      #
+      # @return [ void ]
+      def chunk_length_penalty_size=(value)
+        Curl.set_option(:chunk_length_penalty_size, value, handle, :multi)
+      end
+
+      # Sets pipelining option.
+      #
+      # @example Set pipelining option.
+      #   multi.pipelining = $value
+      #
+      # @param [ Integer ] value The value to set.
+      #
+      # @return [ void ]
+      def pipelining=(value)
+        Curl.set_option(:pipelining, value_for(value, :int, :pipelining), handle, :multi)
+      end
+
+      # Sets socketdata option.
+      #
+      # @example Set socketdata option.
+      #   multi.socketdata = $value
+      #
+      # @param [ FFI::Pointer, nil ] value The value to set.
+      #
+      # @return [ void ]
+      def socketdata=(value)
+        Curl.set_option(:socketdata, value_for(value, :string), handle, :multi)
+      end
+
+      # Sets socketfunction option.
+      #
+      # @example Set socketfunction option.
+      #   multi.socketfunction = $value
+      #
+      # @param [ Proc, nil ] value The value to set.
+      #
+      # @return [ void ]
+      def socketfunction=(value)
+        Curl.set_option(:socketfunction, value_for(value, :string), handle, :multi)
+        retain_callback(:socketfunction, value)
+        value
+      end
+
+      # Sets timerdata option.
+      #
+      # @example Set timerdata option.
+      #   multi.timerdata = $value
+      #
+      # @param [ FFI::Pointer, nil ] value The value to set.
+      #
+      # @return [ void ]
+      def timerdata=(value)
+        Curl.set_option(:timerdata, value_for(value, :string), handle, :multi)
+      end
+
+      # Sets timerfunction option.
+      #
+      # @example Set timerfunction option.
+      #   multi.timerfunction = $value
+      #
+      # @param [ Proc, nil ] value The value to set.
+      #
+      # @return [ void ]
+      def timerfunction=(value)
+        Curl.set_option(:timerfunction, value_for(value, :string), handle, :multi)
+        retain_callback(:timerfunction, value)
+        value
+      end
+
+      private
+
+      # Raise the default connection cache size to twice the largest number
+      # of easy handles ever attached at once.
+      #
+      # libcurl derives its default from the number of handles attached when
+      # a connection is returned. Ethon detaches each handle as soon as its
+      # transfer finishes, so that number falls during a run and libcurl
+      # closes connections that later requests could have reused.
+      #
+      # @param [ Integer ] count The number of attached handles after the
+      #   pending add.
+      #
+      # @return [ void ]
+      def raise_default_maxconnects(count)
+        return if @maxconnects_configured
+        return if count <= (@maxconnects_high_water ||= 0)
+
+        @maxconnects_high_water = count
+        set_maxconnects(2 * count)
+      end
+
+      def set_maxconnects(value)
+        Curl.set_option(:maxconnects, value_for(value, :int, :maxconnects), handle, :multi)
+      end
+
+      def retain_callback(option, callback)
+        if callback.nil?
+          @procs.delete(option) if @procs
+        else
+          (@procs ||= {})[option] = callback
+        end
+        Curl::MultiHandle.retain_callback(handle, option, callback)
+      end
+
+      # Return the value to set to multi handle. It is converted with the help
+      # of bool_options, enum_options and int_options.
+      #
+      # @example Return casted the value.
+      #   multi.value_for(:verbose)
+      #
+      # @return [ Object ] The casted value.
+      def value_for(value, type, option = nil)
+        return nil if value.nil?
+
+        if type == :bool
+          value ? 1 : 0
+        elsif type == :int
+          Ethon::Curls::Options.integer_value(option, value)
+        elsif value.is_a?(String)
+          Ethon::Easy::Util.escape_zero_byte(value)
+        else
+          value
+        end
+      end
+
+    end
+  end
+end