postfinancecheckout-ruby-sdk 3.0.2 → 3.3.0

data/vendor/bundle/ruby/2.7.0/gems/ethon-0.16.0/lib/ethon/multi/operations.rb

@@ -0,0 +1,228 @@
+# 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
+        @handle ||= FFI::AutoPointer.new(Curl.multi_init, Curl.method(:multi_cleanup))
+      end
+
+      # Initialize variables.
+      #
+      # @example Initialize variables.
+      #   multi.init_vars
+      #
+      # @return [ void ]
+      def init_vars
+        if @execution_mode == :perform
+          @timeout = ::FFI::MemoryPointer.new(:long)
+          @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)
+        elsif @execution_mode == :socket_action
+          @running_count_pointer = FFI::MemoryPointer.new(:int)
+        end
+      end
+
+      # Perform multi.
+      #
+      # @return [ nil ]
+      #
+      # @example Perform multi.
+      #   multi.perform
+      def perform
+        ensure_execution_mode(:perform)
+
+        Ethon.logger.debug(STARTED_MULTI)
+        while ongoing?
+          run
+          timeout = get_timeout
+          next if timeout == 0
+          reset_fds
+          set_fds(timeout)
+        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 necessay to call "+
+          "Multi#prepare. Its going to be removed "+
+          "in future versions."
+        )
+      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])
+      #
+      # @return [ Symbol ] The Curl.multi_socket_action return code.
+      def socket_action(io = nil, readiness = 0)
+        ensure_execution_mode(:socket_action)
+
+        fd = if io.nil?
+          ::Ethon::Curl::SOCKET_TIMEOUT
+        elsif io.is_a?(Integer)
+          io
+        else
+          io.fileno
+        end
+
+        code = Curl.multi_socket_action(handle, fd, readiness, @running_count_pointer)
+        @running_count = @running_count_pointer.read_int
+
+        check
+
+        code
+      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?
+        easy_handles.size > 0 || (!defined?(@running_count) || running_count > 0)
+      end
+
+      private
+
+      # 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
+          sleep(0.001)
+        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 = ::FFI::MemoryPointer.new(:int)
+        while true
+          msg = Curl.multi_info_read(handle, msgs_left)
+          break if msg.null?
+          next if msg[:code] != :done
+          easy = easy_handles.find{ |e| e.handle == msg[:easy_handle] }
+          easy.return_code = msg[:data][:code]
+          Ethon.logger.debug { "ETHON:         performed #{easy.log_inspect}" }
+          delete(easy)
+          easy.complete
+        end
+      end
+
+      # Run.
+      #
+      # @example Run
+      #   multi.run
+      #
+      # @return [ void ]
+      def run
+        running_count_pointer = FFI::MemoryPointer.new(:int)
+        begin code = trigger(running_count_pointer) end while code == :call_multi_perform
+        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 ||= nil
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/ethon-0.16.0/lib/ethon/multi/options.rb

@@ -0,0 +1,117 @@
+# 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_conections = $value
+      #
+      # @param [ String ] value The value to set.
+      #
+      # @return [ void ]
+      def max_total_connections=(value)
+        Curl.set_option(:max_total_connections, value_for(value, :int), handle, :multi)
+      end
+
+      # Sets maxconnects option.
+      #
+      # @example Set maxconnects option.
+      #   multi.maxconnects = $value
+      #
+      # @param [ String ] value The value to set.
+      #
+      # @return [ void ]
+      def maxconnects=(value)
+        Curl.set_option(:maxconnects, value_for(value, :int), handle, :multi)
+      end
+
+      # Sets pipelining option.
+      #
+      # @example Set pipelining option.
+      #   multi.pipelining = $value
+      #
+      # @param [ String ] value The value to set.
+      #
+      # @return [ void ]
+      def pipelining=(value)
+        Curl.set_option(:pipelining, value_for(value, :int), handle, :multi)
+      end
+
+      # Sets socketdata option.
+      #
+      # @example Set socketdata option.
+      #   multi.socketdata = $value
+      #
+      # @param [ String ] 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 [ String ] value The value to set.
+      #
+      # @return [ void ]
+      def socketfunction=(value)
+        Curl.set_option(:socketfunction, value_for(value, :string), handle, :multi)
+      end
+
+      # Sets timerdata option.
+      #
+      # @example Set timerdata option.
+      #   multi.timerdata = $value
+      #
+      # @param [ String ] 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 [ String ] value The value to set.
+      #
+      # @return [ void ]
+      def timerfunction=(value)
+        Curl.set_option(:timerfunction, value_for(value, :string), handle, :multi)
+      end
+
+      private
+
+      # 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
+          value.to_i
+        elsif value.is_a?(String)
+          Ethon::Easy::Util.escape_zero_byte(value)
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/ethon-0.16.0/lib/ethon/multi/stack.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+module Ethon
+  class Multi
+
+    # This module provides the multi stack behaviour.
+    module Stack
+
+      # Return easy handles.
+      #
+      # @example Return easy handles.
+      #   multi.easy_handles
+      #
+      # @return [ Array ] The easy handles.
+      def easy_handles
+        @easy_handles ||= []
+      end
+
+      # Add an easy to the stack.
+      #
+      # @example Add easy.
+      #   multi.add(easy)
+      #
+      # @param [ Easy ] easy The easy to add.
+      #
+      # @raise [ Ethon::Errors::MultiAdd ] If adding an easy failed.
+      def add(easy)
+        return nil if easy_handles.include?(easy)
+
+        code = Curl.multi_add_handle(handle, easy.handle)
+        raise Errors::MultiAdd.new(code, easy) unless code == :ok
+        easy_handles << easy
+      end
+
+      # Delete an easy from stack.
+      #
+      # @example Delete easy from stack.
+      #
+      # @param [ Easy ] easy The easy to delete.
+      #
+      # @raise [ Ethon::Errors::MultiRemove ] If removing an easy failed.
+      def delete(easy)
+        if easy_handles.delete(easy)
+          code = Curl.multi_remove_handle(handle, easy.handle)
+          raise Errors::MultiRemove.new(code, handle) unless code == :ok
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/ethon-0.16.0/lib/ethon/multi.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+require 'ethon/easy/util'
+require 'ethon/multi/stack'
+require 'ethon/multi/operations'
+require 'ethon/multi/options'
+
+module Ethon
+
+  # This class represents libcurl multi.
+  class Multi
+    include Ethon::Multi::Stack
+    include Ethon::Multi::Operations
+    include Ethon::Multi::Options
+
+    # Create a new multi. Initialize curl in case
+    # it didn't happen before.
+    #
+    # @example Create a new Multi.
+    #   Multi.new
+    #
+    # @param [ Hash ] options The options.
+    #
+    # @option options :socketdata [String]
+    #  Pass a pointer to whatever you want passed to the
+    #  curl_socket_callback's forth argument, the userp pointer. This is not
+    #  used by libcurl but only passed-thru as-is. Set the callback pointer
+    #  with CURLMOPT_SOCKETFUNCTION.
+    # @option options :pipelining [Boolean]
+    #  Pass a long set to 1 to enable or 0 to disable. Enabling pipelining
+    #  on a multi handle will make it attempt to perform HTTP Pipelining as
+    #  far as possible for transfers using this handle. This means that if
+    #  you add a second request that can use an already existing connection,
+    #  the second request will be "piped" on the same connection rather than
+    #  being executed in parallel. (Added in 7.16.0)
+    # @option options :timerfunction [Proc]
+    #  Pass a pointer to a function matching the curl_multi_timer_callback
+    #  prototype. This function will then be called when the timeout value
+    #  changes. The timeout value is at what latest time the application
+    #  should call one of the "performing" functions of the multi interface
+    #  (curl_multi_socket_action(3) and curl_multi_perform(3)) - to allow
+    #  libcurl to keep timeouts and retries etc to work. A timeout value of
+    #  -1 means that there is no timeout at all, and 0 means that the
+    #  timeout is already reached. Libcurl attempts to limit calling this
+    #  only when the fixed future timeout time actually changes. See also
+    #  CURLMOPT_TIMERDATA. This callback can be used instead of, or in
+    #  addition to, curl_multi_timeout(3). (Added in 7.16.0)
+    # @option options :timerdata [String]
+    #  Pass a pointer to whatever you want passed to the
+    #  curl_multi_timer_callback's third argument, the userp pointer. This
+    #  is not used by libcurl but only passed-thru as-is. Set the callback
+    #  pointer with CURLMOPT_TIMERFUNCTION. (Added in 7.16.0)
+    # @option options :maxconnects [Integer]
+    #  Pass a long. The set number will be used as the maximum amount of
+    #  simultaneously open connections that libcurl may cache. Default is
+    #  10, and libcurl will enlarge the size for each added easy handle to
+    #  make it fit 4 times the number of added easy handles.
+    #  By setting this option, you can prevent the cache size from growing
+    #  beyond the limit set by you.
+    #  When the cache is full, curl closes the oldest one in the cache to
+    #  prevent the number of open connections from increasing.
+    #  This option is for the multi handle's use only, when using the easy
+    #  interface you should instead use the CURLOPT_MAXCONNECTS option.
+    #  (Added in 7.16.3)
+    # @option options :max_total_connections [Integer]
+    # Pass a long. The set number will be used as the maximum amount of 
+    # simultaneously open connections in total. For each new session, 
+    # libcurl will open a new connection up to the limit set by 
+    # CURLMOPT_MAX_TOTAL_CONNECTIONS. When the limit is reached, the 
+    # sessions will be pending until there are available connections. 
+    # If CURLMOPT_PIPELINING is 1, libcurl will try to pipeline if the host 
+    # is capable of it.
+    # The default value is 0, which means that there is no limit. However, 
+    # for backwards compatibility, setting it to 0 when CURLMOPT_PIPELINING 
+    # is 1 will not be treated as unlimited. Instead it will open only 1 
+    # connection and try to pipeline on it.
+    # (Added in 7.30.0)
+    # @option options :execution_mode [Boolean]
+    #  Either :perform (default) or :socket_action, specifies the usage
+    #  method that will be used on this multi object. The default :perform
+    #  mode provides a #perform function that uses curl_multi_perform
+    #  behind the scenes to automatically continue execution until all
+    #  requests have completed. The :socket_action mode provides an API
+    #  that allows the {Multi} object to be integrated into an external
+    #  IO loop, by calling #socket_action and responding to the 
+    #  socketfunction and timerfunction callbacks, using the underlying
+    #  curl_multi_socket_action semantics.
+    #
+    # @return [ Multi ] The new multi.
+    def initialize(options = {})
+      Curl.init
+      @execution_mode = options.delete(:execution_mode) || :perform
+      set_attributes(options)
+      init_vars
+    end
+
+    # Set given options.
+    #
+    # @example Set options.
+    #   multi.set_attributes(options)
+    #
+    # @raise InvalidOption
+    #
+    # @see initialize
+    #
+    # @api private
+    def set_attributes(options)
+      options.each_pair do |key, value|
+        unless respond_to?("#{key}=")
+          raise Errors::InvalidOption.new(key)
+        end
+        method("#{key}=").call(value)
+      end
+    end
+
+    private
+
+    # Internal function to gate functions to a specific execution mode
+    #
+    # @raise ArgumentError
+    #
+    # @api private
+    def ensure_execution_mode(expected_mode)
+      raise ArgumentError, "Expected the Multi to be in #{expected_mode} but it was in #{@execution_mode}" if expected_mode != @execution_mode
+    end
+  end
+end

data/vendor/bundle/ruby/2.7.0/gems/ethon-0.16.0/lib/ethon/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module Ethon
+
+  # Ethon version.
+  VERSION = '0.16.0'
+end

data/vendor/bundle/ruby/2.7.0/gems/ethon-0.16.0/lib/ethon.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+require 'logger'
+require 'ffi'
+require 'thread'
+begin
+  require 'mime/types/columnar'
+rescue LoadError
+  begin
+    require 'mime/types'
+  rescue LoadError
+  end
+end
+require 'tempfile'
+
+require 'ethon/libc'
+require 'ethon/curl'
+require 'ethon/easy'
+require 'ethon/errors'
+require 'ethon/loggable'
+require 'ethon/multi'
+require 'ethon/version'
+
+# Ethon is a very simple libcurl.
+# It provides direct access to libcurl functionality
+# as well as some helpers for doing http requests.
+#
+# Ethon was extracted from Typhoeus. If you want to
+# see how others use Ethon look at the Typhoeus code.
+#
+# @see https://www.github.com/typhoeus/typhoeus Typhoeus
+#
+# @note Please update to the latest libcurl version in order
+#   to benefit from all features and bugfixes.
+#   http://curl.haxx.se/download.html
+module Ethon
+end

data/vendor/bundle/ruby/2.7.0/gems/ethon-0.16.0/profile/benchmarks.rb

@@ -0,0 +1,104 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'ethon'
+require 'open-uri'
+require 'patron'
+require 'curb'
+require 'net/http'
+require 'cgi'
+require 'benchmark/ips'
+
+require_relative '../spec/support/server'
+require_relative '../spec/support/localhost_server'
+
+LocalhostServer.new(TESTSERVER.new, 3000)
+LocalhostServer.new(TESTSERVER.new, 3001)
+LocalhostServer.new(TESTSERVER.new, 3002)
+
+url = 'http://localhost:3000/'.freeze
+uri = URI.parse('http://localhost:3000/').freeze
+ethon = Ethon::Easy.new(url: url)
+patron = Patron::Session.new
+patron_url = Patron::Session.new(base_url: url)
+curb = Curl::Easy.new(url)
+
+puts '[Creation]'
+Benchmark.ips do |x|
+  x.report('String.new') { '' }
+  x.report('Easy.new') { Ethon::Easy.new }
+end
+
+puts '[Escape]'
+Benchmark.ips do |x|
+  x.report('CGI.escape') { CGI.escape("まつもと") }
+  x.report('Easy.escape') { ethon.escape("まつもと") }
+end
+
+puts '[Requests]'
+Benchmark.ips do |x|
+  x.report('net/http') { Net::HTTP.get_response(uri) }
+  x.report('open-uri') { open url }
+
+  x.report('patron') do
+    patron.base_url = url
+    patron.get('/')
+  end
+
+  x.report('patron reuse') { patron_url.get('/') }
+
+  x.report('curb') do
+    curb.url = url
+    curb.perform
+  end
+
+  x.report('curb reuse') { curb.perform }
+
+  x.report('Easy.perform') do
+    ethon.url = url
+    ethon.perform
+  end
+
+  x.report('Easy.perform reuse') { ethon.perform }
+end
+
+puts "[ 4 delayed Requests ]"
+Benchmark.ips do |x|
+  x.report('net/http') do
+    3.times do |i|
+      uri = URI.parse("http://localhost:300#{i}/?delay=1")
+      Net::HTTP.get_response(uri)
+    end
+  end
+
+  x.report("open-uri") do
+    3.times do |i|
+      open("http://localhost:300#{i}/?delay=1")
+    end
+  end
+
+  x.report("patron") do
+    sess = Patron::Session.new
+    3.times do |i|
+      sess.base_url = "http://localhost:300#{i}/?delay=1"
+      sess.get("/")
+    end
+  end
+
+  x.report("Easy.perform") do
+    easy = Ethon::Easy.new
+    3.times do |i|
+      easy.url = "http://localhost:300#{i}/?delay=1"
+      easy.perform
+    end
+  end
+
+  x.report("Multi.perform") do
+    multi = Ethon::Multi.new
+    3.times do |i|
+      easy = Ethon::Easy.new
+      easy.url = "http://localhost:300#{i}/?delay=1"
+      multi.add(easy)
+    end
+    multi.perform
+  end
+end