kruby 1.36.0.2 → 1.36.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0339eb1cc8a6f1d7402b0f089dca4cdd7fd20c0b0f0a049cec2b3fcd0a78276
-  data.tar.gz: 3416b24a60f29e7715a9ff45a1f542dbc83c325c988c51e9c288e6a618403f85
+  metadata.gz: a427ec5d2c6e70a8edf267a9095e38b988bfef3501dc420145de416fd8aea1aa
+  data.tar.gz: 6ddad098a7d16fde73bf1861b2aa4c1b4dd7559821b4d238bd58474a28bc1a99
 SHA512:
-  metadata.gz: 4d3b65bb69cb397cb29704318d5359d570aa55113c7e45e99930b11606628c301e08404671373f35bdb0bfb9e64e67399ea682f770f4900fb73e82c559c41b98
-  data.tar.gz: bc2755b8608df879b0b5abffafb0255096abdde11d2a37d3e689e97d1113fa4c12818016c617b74308f3953f38aac989e2bae3cd6a732c9d59a11b5d3a100e3a
+  metadata.gz: 1ddbe0af5eaa1ae160af1e07d7c9b54209dd064fc20362a81e93b8f709ba01feb6f4835995652db3984d27b46501cf029a3b9dfbc87252175638392f40feb761
+  data.tar.gz: 5959a6ec6db11ae3e323f6759add33c9c9a57cde7d1f5727c37138f2603129b2814ec5e803fe015289e9d60be2c551e135ce58353c380cf27e310e1b0ed4ab59

data/lib/kubernetes/api_client.rb

@@ -15,10 +15,13 @@ require 'json'
 require 'logger'
 require 'tempfile'
 require 'time'
+require 'thread'
 require 'typhoeus'
 
 module Kubernetes
   class ApiClient
+    @default_mutex = Mutex.new
+
     # The Configuration object holding settings to be used in the API client.
     attr_accessor :config
 
@@ -39,7 +42,17 @@ module Kubernetes
     end
 
     def self.default
-      @@default ||= ApiClient.new
+      return @@default if defined?(@@default) && @@default
+
+      @default_mutex.synchronize do
+        @@default ||= ApiClient.new
+      end
+    end
+
+    def self.reset_default
+      @default_mutex.synchronize do
+        @@default = nil
+      end
     end
 
     # Call an API with given options.
@@ -47,34 +60,43 @@ module Kubernetes
     # @return [Array<(Object, Integer, Hash)>] an array of 3 elements:
     #   the data deserialized from response body (could be nil), response status code and response headers.
     def call_api(http_method, path, opts = {})
-      request = build_request(http_method, path, opts)
-      response = request.run
+      retries_performed = 0
 
-      if @config.debugging
-        @config.logger.debug "HTTP response body ~BEGIN~\n#{response.body}\n~END~\n"
-      end
+      loop do
+        request = build_request(http_method, path, opts)
+        response = request.run
 
-      unless response.success?
-        if response.timed_out?
-          fail ApiError.new('Connection timed out')
-        elsif response.code == 0
-          # Errors from libcurl will be made visible here
-          fail ApiError.new(:code => 0,
-                            :message => response.return_message)
-        else
-          fail ApiError.new(:code => response.code,
-                            :response_headers => response.headers,
-                            :response_body => response.body),
-               response.status_message
+        if @config.debugging
+          @config.logger.debug "HTTP response body ~BEGIN~\n#{response.body}\n~END~\n"
         end
-      end
 
-      if opts[:return_type]
-        data = deserialize(response, opts[:return_type])
-      else
-        data = nil
+        unless response.success?
+          if retry_request?(response, retries_performed)
+            interval_seconds = retry_interval_seconds(response, retries_performed)
+            log_retry_attempt(response, retries_performed + 1, interval_seconds)
+            sleep interval_seconds
+            retries_performed += 1
+            next
+          end
+
+          if response.timed_out?
+            fail ApiError.new(:code => 0,
+                              :message => 'Connection timed out')
+          elsif response.code == 0
+            # Errors from libcurl will be made visible here
+            fail ApiError.new(:code => 0,
+                              :message => response.return_message)
+          else
+            fail ApiError.new(:code => response.code,
+                              :response_headers => response.headers,
+                              :response_body => response.body),
+                 response.status_message
+          end
+        end
+
+        data = opts[:return_type] ? deserialize(response, opts[:return_type]) : nil
+        return data, response.code, response.headers
       end
-      return data, response.code, response.headers
     end
 
     # Builds the HTTP request
@@ -225,7 +247,12 @@ module Kubernetes
       # ensuring a default content type
       content_type = response.headers['Content-Type'] || 'application/json'
 
-      fail "Content-Type is not supported: #{content_type}" unless json_mime?(content_type)
+      unless json_mime?(content_type)
+        fail ApiError.new(:code => response.code,
+                          :response_headers => response.headers,
+                          :response_body => body,
+                          :message => "Content-Type is not supported: #{content_type}")
+      end
 
       begin
         data = JSON.parse("[#{body}]", :symbolize_names => true)[0]
@@ -399,5 +426,85 @@ module Kubernetes
         fail "unknown collection format: #{collection_format.inspect}"
       end
     end
+
+    def retry_request?(response, retries_performed)
+      return false if response.timed_out?
+      return false if response.code.to_i == 0
+      return false if max_retry_attempts <= 0
+      return false if retries_performed >= max_retry_attempts
+
+      retry_statuses.include?(response.code.to_i)
+    end
+
+    def retry_interval_seconds(response, retries_performed)
+      exponential_interval = retry_base_interval_seconds * (2**retries_performed)
+      server_interval = server_retry_after_seconds(response)
+
+      server_interval ? [exponential_interval, server_interval].max : exponential_interval
+    end
+
+    def log_retry_attempt(response, retry_number, interval_seconds)
+      @config.logger.info(
+        "Retrying API request after HTTP #{response.code} (retry #{retry_number}/#{max_retry_attempts}) in #{interval_seconds} seconds"
+      )
+      return unless @config.debugging
+
+      @config.logger.debug("Retry response body: #{response.body}")
+    end
+
+    def max_retry_attempts
+      value = fetch_retry_configuration(:max_retries, 0)
+      [value.to_i, 0].max
+    end
+
+    def retry_base_interval_seconds
+      [fetch_retry_configuration(:base_interval_seconds, 1.0).to_f, 0.0].max
+    end
+
+    def retry_statuses
+      Array(fetch_retry_configuration(:retry_statuses, [429, 500, 501, 502, 503])).map(&:to_i)
+    end
+
+    def server_retry_after_seconds(response)
+      header_value = response.headers['Retry-After'] if response.respond_to?(:headers) && response.headers.is_a?(Hash)
+      header_seconds = parse_retry_after_header(header_value)
+      return header_seconds if header_seconds
+
+      parse_retry_after_from_body(response.body)
+    end
+
+    def parse_retry_after_header(header_value)
+      return nil if header_value.nil?
+
+      integer_value = Integer(header_value, exception: false)
+      return integer_value.to_f if integer_value
+
+      retry_at = Time.httpdate(header_value)
+      [retry_at - Time.now, 0.0].max
+    rescue ArgumentError
+      nil
+    end
+
+    def parse_retry_after_from_body(body)
+      return nil if body.nil? || body.empty?
+
+      parsed = JSON.parse(body)
+      retry_after = parsed.dig('details', 'retryAfterSeconds') || parsed.dig(:details, :retryAfterSeconds)
+      return nil if retry_after.nil?
+
+      retry_after.to_f
+    rescue JSON::ParserError, TypeError
+      nil
+    end
+
+    def fetch_retry_configuration(key, default)
+      return default unless @config.retry_configuration.is_a?(Hash)
+
+      if @config.retry_configuration.key?(key)
+        @config.retry_configuration[key]
+      else
+        @config.retry_configuration.fetch(key.to_s, default)
+      end
+    end
   end
 end

data/lib/kubernetes/config/incluster_config.rb

@@ -90,13 +90,13 @@ module Kubernetes
       Configuration.instance_variable_set(:@in_cluster_config, self)
       Configuration.prepend(Module.new do
         # rubocop:disable Metrics/LineLength
-        def api_key_with_prefix(identifier)
+        def api_key_with_prefix(identifier, param_alias = nil)
           in_cluster_config = self.class.instance_variable_get(:@in_cluster_config)
           if identifier == 'authorization' && @api_key.key?(identifier) && in_cluster_config.token_expires_at <= Time.now
             in_cluster_config.load_token
             @api_key[identifier] = 'Bearer ' + in_cluster_config.token
           end
-          super identifier
+          super identifier, param_alias
         end
         # rubocop:enable Metrics/LineLength
       end)

data/lib/kubernetes/config/kube_config.rb

@@ -49,6 +49,13 @@ module Kubernetes
       File.dirname(path)
     end
 
+    def resolve_path(file_path)
+      return file_path unless file_path
+      file_path = file_path.to_s
+      return file_path if file_path.start_with?('/')
+      File.expand_path(file_path, File.expand_path(base_path))
+    end
+
     def config
       @config ||= File.open(path) do |io|
         ::YAML.safe_load(io.read)
@@ -86,8 +93,8 @@ module Kubernetes
 
     def setup_ssl(cluster, user, config)
       # rubocop:disable DoubleNegation
-      config.verify_ssl = !!cluster['verify-ssl']
-      config.verify_ssl_host = !!cluster['verify-ssl']
+      config.verify_ssl = !!cluster['verify_ssl']
+      config.verify_ssl_host = !!cluster['verify_ssl']
       # rubocop:enable DoubleNegation
 
       config.ssl_ca_cert = cluster['certificate-authority']
@@ -98,6 +105,7 @@ module Kubernetes
     def find_cluster(name)
       find_by_name(config['clusters'], 'cluster', name).tap do |cluster|
         Kubernetes.create_temp_file_and_set(cluster, 'certificate-authority')
+        cluster['certificate-authority'] = resolve_path(cluster['certificate-authority'])
         cluster['verify_ssl'] = !cluster['insecure-skip-tls-verify']
       end
     end
@@ -108,6 +116,8 @@ module Kubernetes
 
         Kubernetes.create_temp_file_and_set(user, 'client-certificate')
         Kubernetes.create_temp_file_and_set(user, 'client-key')
+        user['client-certificate'] = resolve_path(user['client-certificate'])
+        user['client-key'] = resolve_path(user['client-key'])
         load_token_file(user)
         setup_auth(user)
       end
@@ -117,6 +127,7 @@ module Kubernetes
       # If tokenFile is specified, then set token
       return unless !user['token'] && user['tokenFile']
 
+      user['tokenFile'] = resolve_path(user['tokenFile'])
       File.open(user['tokenFile']) do |io|
         user['token'] = io.read.chomp
       end

data/lib/kubernetes/configuration.rb

@@ -11,9 +11,12 @@ OpenAPI Generator version: 5.1.0
 =end
 
 require 'logger'
+require 'thread'
 
 module Kubernetes
   class Configuration
+    @default_mutex = Mutex.new
+
     # Defines url scheme
     attr_accessor :scheme
 
@@ -88,6 +91,11 @@ module Kubernetes
     # Default to 0 (never times out).
     attr_accessor :timeout
 
+    # Optional retry configuration for retriable HTTP responses.
+    # Example:
+    #   { max_retries: 4, base_interval_seconds: 1.0, retry_statuses: [429, 500, 501, 502, 503] }
+    attr_accessor :retry_configuration
+
     # Set this to false to skip client side validation in the operation.
     # Default to true.
     # @return [true, false]
@@ -150,6 +158,7 @@ module Kubernetes
       @api_key = {}
       @api_key_prefix = {}
       @timeout = 0
+      @retry_configuration = nil
       @client_side_validation = true
       @verify_ssl = true
       @verify_ssl_host = true
@@ -166,7 +175,17 @@ module Kubernetes
 
     # The default Configuration object.
     def self.default
-      @@default ||= Configuration.new
+      return @@default if defined?(@@default) && @@default
+
+      @default_mutex.synchronize do
+        @@default ||= Configuration.new
+      end
+    end
+
+    def self.reset_default
+      @default_mutex.synchronize do
+        @@default = nil
+      end
     end
 
     # Backward-compatible alias used by examples and older integrations.
@@ -260,21 +279,30 @@ module Kubernetes
       end
 
       server = servers[index]
-      url = server[:url]
+      url = server[:url].dup
 
       return url unless server.key? :variables
 
       # go through variable and assign a value
       server[:variables].each do |name, variable|
-        if variables.key?(name)
-          if (!server[:variables][name].key?(:enum_values) || server[:variables][name][:enum_values].include?(variables[name]))
-            url.gsub! "{" + name.to_s + "}", variables[name]
+        variable_key = if variables.key?(name)
+                         name
+                       elsif variables.key?(name.to_s)
+                         name.to_s
+                       elsif name.respond_to?(:to_sym) && variables.key?(name.to_sym)
+                         name.to_sym
+                       end
+
+        if variable_key
+          variable_value = variables[variable_key]
+          if (!variable.key?(:enum_values) || variable[:enum_values].include?(variable_value))
+            url.gsub! "{" + name.to_s + "}", variable_value
           else
-            fail ArgumentError, "The variable `#{name}` in the server URL has invalid value #{variables[name]}. Must be #{server[:variables][name][:enum_values]}."
+            fail ArgumentError, "The variable `#{name}` in the server URL has invalid value #{variable_value}. Must be #{variable[:enum_values]}."
           end
         else
           # use default value
-          url.gsub! "{" + name.to_s + "}", server[:variables][name][:default_value]
+          url.gsub! "{" + name.to_s + "}", variable[:default_value]
         end
       end
 

data/lib/kubernetes/release/publish_guard.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "open3"
+require "rubygems/specification"
+require "shellwords"
+require "kubernetes/release/changelog"
+
+module Kubernetes
+  module Release
+    module PublishGuard
+      module_function
+
+      def gemspec_files(gemspec_path)
+        spec = Gem::Specification.load(gemspec_path)
+        raise Changelog::Error, "failed to load gemspec #{gemspec_path}" unless spec
+
+        spec.files
+      rescue Gem::InvalidSpecificationException => e
+        raise Changelog::Error, e.message
+      end
+
+      def untracked_package_files(repo_root:, package_root:, package_files:)
+        repo_paths = package_files.map do |path|
+          package_file_repo_path(repo_root: repo_root, package_root: package_root, package_path: path)
+        end.uniq.sort
+        return [] if repo_paths.empty?
+
+        tracked_paths = capture_command("git", "-C", repo_root, "ls-files", "--", *repo_paths).lines.map(&:chomp)
+        repo_paths - tracked_paths
+      end
+
+      def untracked_gemspec_files(repo_root:, package_root:, gemspec_path:)
+        untracked_package_files(
+          repo_root: repo_root,
+          package_root: package_root,
+          package_files: gemspec_files(gemspec_path)
+        )
+      end
+
+      def package_file_repo_path(repo_root:, package_root:, package_path:)
+        repo_root = File.expand_path(repo_root)
+        repo_prefix = "#{repo_root}#{File::SEPARATOR}"
+        full_path = File.expand_path(package_path, package_root)
+
+        unless full_path.start_with?(repo_prefix)
+          raise Changelog::Error, "gem package file #{package_path} resolves outside #{repo_root}"
+        end
+
+        full_path.delete_prefix(repo_prefix)
+      end
+
+      def capture_command(*command)
+        output, status = Open3.capture2e(*command)
+        return output if status.success?
+
+        message = "command failed: #{Shellwords.join(command)}"
+        details = output.strip
+        message = "#{message}\n#{details}" unless details.empty?
+        raise Changelog::Error, message
+      end
+    end
+  end
+end

data/lib/kubernetes/utils.rb

@@ -15,6 +15,7 @@
 require 'kubernetes/config/incluster_config'
 require 'kubernetes/config/kube_config'
 require 'rubygems/version'
+require 'thread'
 
 # The Kubernetes module encapsulates the Kubernetes client for Ruby
 module Kubernetes
@@ -73,18 +74,22 @@ module Kubernetes
   end
 
   @temp_files = {}
+  @temp_files_mutex = Mutex.new
 
   def create_temp_file_with_base64content(content)
-    @temp_files[content] ||= Tempfile.open('kube') do |temp|
-      temp.write(Base64.strict_decode64(content))
-      temp
+    @temp_files_mutex.synchronize do
+      @temp_files[content] ||= Tempfile.open('kube') do |temp|
+        temp.write(Base64.strict_decode64(content))
+        temp
+      end
+      @temp_files.fetch(content).path
     end
-
-    @temp_files[content].path
   end
 
   def clear_temp_files
-    @temp_files = {}
+    @temp_files_mutex.synchronize do
+      @temp_files = {}
+    end
   end
 
   SUPPORTED_KUBERNETES_VERSION_RANGE = (

data/lib/kubernetes/version.rb

@@ -11,5 +11,5 @@ OpenAPI Generator version: 5.1.0
 =end
 
 module Kubernetes
-  VERSION = '1.36.0.2'
+  VERSION = '1.36.0.4'
 end

data/lib/kubernetes/watch.rb

@@ -13,41 +13,74 @@
 # limitations under the License.
 
 require 'json'
+require 'uri'
 
 # The Kubernetes module encapsulates the Kubernetes client for Ruby
 module Kubernetes
   # The Watch class provides the ability to watch a specific resource for
   # updates.
   class Watch
+    MAX_RECONNECT_ATTEMPTS = 3
+    RECONNECT_BACKOFF_SECONDS = 1.0
+
     def initialize(client)
       @client = client
     end
 
     def make_url(path, resource_version)
-      query = '?watch=true'
-      query += "&resourceVersion=#{resource_version}" if resource_version
-      path + query
+      uri = URI.parse(path)
+      query = URI.decode_www_form(uri.query || '').to_h
+      query['watch'] = 'true'
+      query['resourceVersion'] = resource_version if resource_version
+      query_string = query.map { |k, v| "#{URI.encode_www_form_component(k).gsub('+', '%20')}=#{URI.encode_www_form_component(v).gsub('+', '%20')}" }.join('&')
+      "#{uri.path}?#{query_string}"
     end
 
     def connect(path, resource_version = nil, &_block)
-      opts = { auth_names: ['BearerToken'] }
-      url = make_url(path, resource_version)
-      request = @client.build_request('GET', url, opts)
-      last = ''
-      request.on_body do |chunk|
-        last, pieces = split_lines(last, chunk)
-        pieces.each do |part|
-          begin
-            event = JSON.parse(part)
-          rescue JSON::ParserError => e
-            warn "Failed to parse watch event: #{e.message}. Raw event: #{part.inspect}"
+      current_resource_version = resource_version
+      reconnect_attempts = 0
+
+      loop do
+        reconnect_requested = false
+        opts = { auth_names: ['BearerToken'] }
+        url = make_url(path, current_resource_version)
+        request = @client.build_request('GET', url, opts)
+        last = ''
+
+        process_event = lambda do |part|
+          return if part.nil? || part.strip.empty?
+
+          event = parse_event(part)
+          return unless event
+
+          if watch_reset_event?(event)
+            current_resource_version = nil
+            reconnect_requested = true
             next
           end
 
+          current_resource_version = extract_resource_version(event) || current_resource_version
           yield event
         end
+
+        request.on_body do |chunk|
+          last, pieces = split_lines(last, chunk)
+          pieces.each { |part| process_event.call(part) }
+        end
+
+        request.on_complete do |_response|
+          process_event.call(last)
+          last = ''
+        end
+
+        response = request.run
+        reconnect_reason = reconnect_reason(response, reconnect_requested)
+        return response unless reconnect_reason
+        raise_terminal_watch_error(response, reconnect_reason) if reconnect_attempts >= MAX_RECONNECT_ATTEMPTS
+
+        reconnect_attempts += 1
+        sleep reconnect_backoff_seconds(reconnect_attempts - 1) if reconnect_reason == :transport
       end
-      request.run
     end
 
     def split_lines(last, chunk)
@@ -61,5 +94,51 @@ module Kubernetes
       last = data[(ix + 1)..data.length]
       [last, complete.split(/\n/)]
     end
+
+    private
+
+    def parse_event(part)
+      JSON.parse(part)
+    rescue JSON::ParserError => e
+      warn "Failed to parse watch event: #{e.message}. Raw event: #{part.inspect}"
+      nil
+    end
+
+    def extract_resource_version(event)
+      object = event['object']
+      return nil unless object.is_a?(Hash)
+
+      metadata = object['metadata']
+      return metadata['resourceVersion'] if metadata.is_a?(Hash)
+
+      object['resourceVersion']
+    end
+
+    def watch_reset_event?(event)
+      event['type'] == 'ERROR' && event.dig('object', 'code').to_i == 410
+    end
+
+    def reconnect_reason(response, reconnect_requested)
+      return :reset if reconnect_requested
+      return nil unless response
+
+      return :transport if response.timed_out? || response.code.to_i.zero?
+
+      nil
+    end
+
+    def reconnect_backoff_seconds(reconnect_attempt)
+      RECONNECT_BACKOFF_SECONDS * (2**reconnect_attempt)
+    end
+
+    def raise_terminal_watch_error(response, reconnect_reason)
+      if reconnect_reason == :reset
+        raise ApiError.new(code: 410, message: 'Watch resource version expired')
+      elsif response&.timed_out?
+        raise ApiError.new('Watch connection timed out')
+      elsif response && response.code.to_i.zero?
+        raise ApiError.new(code: 0, message: response.return_message)
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kruby
 version: !ruby/object:Gem::Version
-  version: 1.36.0.2
+  version: 1.36.0.4
 platform: ruby
 authors:
 - doridoridoriand
@@ -903,6 +903,7 @@ files:
 - lib/kubernetes/models/v2_resource_metric_status.rb
 - lib/kubernetes/models/version_info.rb
 - lib/kubernetes/release/changelog.rb
+- lib/kubernetes/release/publish_guard.rb
 - lib/kubernetes/utils.rb
 - lib/kubernetes/version.rb
 - lib/kubernetes/watch.rb