kubeclient 2.5.2 → 3.0.0

data/Rakefile

@@ -3,10 +3,7 @@ require 'rake/testtask'
 require 'rubocop/rake_task'
 require 'yaml'
 
-task default: [:test, :rubocop] # same as .travis.yml
-
-Rake::TestTask.new do |t|
-  t.libs << 'test'
-end
+task default: %i[test rubocop] # same as .travis.yml
 
+Rake::TestTask.new
 RuboCop::RakeTask.new

data/kubeclient.gemspec

@@ -1,4 +1,5 @@
 # coding: utf-8
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'kubeclient/version'
@@ -17,15 +18,16 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
-  spec.required_ruby_version = '>= 2.0.0'
+  spec.required_ruby_version = '>= 2.2.0'
 
   spec.add_development_dependency 'bundler', '~> 1.6'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake', '~> 12.0'
   spec.add_development_dependency 'minitest'
-  spec.add_development_dependency 'webmock', '~> 1.24.2'
+  spec.add_development_dependency 'minitest-rg'
+  spec.add_development_dependency 'webmock', '~> 3.0.1'
   spec.add_development_dependency 'vcr'
-  spec.add_development_dependency 'rubocop', '= 0.30.0'
-  spec.add_dependency 'rest-client'
-  spec.add_dependency 'recursive-open-struct', '~> 1.0.0'
-  spec.add_dependency 'http', '< 3', '>= 0.98'
+  spec.add_development_dependency 'rubocop', '= 0.49.1'
+  spec.add_dependency 'rest-client', '~> 2.0'
+  spec.add_dependency 'recursive-open-struct', '~> 1.0.4'
+  spec.add_dependency 'http', '~> 2.2.2'
 end

data/lib/kubeclient.rb

@@ -1,27 +1,27 @@
-require 'kubeclient/version'
 require 'json'
 require 'rest-client'
-require 'kubeclient/entity_list'
-require 'kubeclient/kube_exception'
-require 'kubeclient/watch_notice'
-require 'kubeclient/watch_stream'
+
 require 'kubeclient/common'
 require 'kubeclient/config'
+require 'kubeclient/entity_list'
+require 'kubeclient/http_error'
 require 'kubeclient/missing_kind_compatibility'
+require 'kubeclient/resource'
+require 'kubeclient/resource_not_found_error'
+require 'kubeclient/version'
+require 'kubeclient/watch_notice'
+require 'kubeclient/watch_stream'
 
 module Kubeclient
   # Kubernetes Client
   class Client
     include ClientMixin
-    # define a multipurpose resource class, available before discovery
-    ClientMixin.resource_class(Kubeclient, 'Resource')
     def initialize(
       uri,
       version = 'v1',
       **options
     )
       initialize_client(
-        Kubeclient,
         uri,
         '/api',
         version,

data/lib/kubeclient/common.rb

@@ -4,7 +4,7 @@ module Kubeclient
   # Common methods
   # this is mixed in by other gems
   module ClientMixin
-    ENTITY_METHODS = %w(get watch delete create update patch)
+    ENTITY_METHODS = %w[get watch delete create update patch].freeze
 
     DEFAULT_SSL_OPTIONS = {
       client_cert: nil,
@@ -49,7 +49,6 @@ module Kubeclient
     attr_reader :discovered
 
     def initialize_client(
-      class_owner,
       uri,
       path,
       version,
@@ -62,7 +61,6 @@ module Kubeclient
       validate_auth_options(auth_options)
       handle_uri(uri, path)
 
-      @class_owner = class_owner
       @entities = {}
       @discovered = false
       @api_version = version
@@ -73,7 +71,7 @@ module Kubeclient
       # Allow passing partial timeouts hash, without unspecified
       # @timeouts[:foo] == nil resulting in infinite timeout.
       @timeouts = DEFAULT_TIMEOUTS.merge(timeouts)
-      @http_proxy_uri = http_proxy_uri.to_s if http_proxy_uri
+      @http_proxy_uri = http_proxy_uri ? http_proxy_uri.to_s : nil
 
       if auth_options[:bearer_token]
         bearer_token(@auth_options[:bearer_token])
@@ -114,7 +112,8 @@ module Kubeclient
         {}
       end
       err_message = json_error_msg['message'] || e.message
-      raise KubeException.new(e.http_code, err_message, e.response)
+      error_klass = e.http_code == 404 ? ResourceNotFoundError : HttpError
+      raise error_klass.new(e.http_code, err_message, e.response)
     end
 
     def discover
@@ -126,9 +125,9 @@ module Kubeclient
     def self.parse_definition(kind, name)
       # "name": "componentstatuses", networkpolicies, endpoints
       # "kind": "ComponentStatus" NetworkPolicy, Endpoints
-      # maintain pre group api compatibility for endpoints.
+      # maintain pre group api compatibility for endpoints and securitycontextconstraints.
       # See: https://github.com/kubernetes/kubernetes/issues/8115
-      kind = 'Endpoint' if kind == 'Endpoints'
+      kind = kind[0..-2] if %w[Endpoints SecurityContextConstraints].include?(kind)
 
       prefix = kind[0..kind.rindex(/[A-Z]/)] # NetworkP
       m = name.match(/^#{prefix.downcase}(.*)$/)
@@ -143,10 +142,10 @@ module Kubeclient
     end
 
     def handle_uri(uri, path)
-      fail ArgumentError, 'Missing uri' unless uri
+      raise ArgumentError, 'Missing uri' unless uri
       @api_endpoint = (uri.is_a?(URI) ? uri : URI.parse(uri))
       @api_endpoint.path = path if @api_endpoint.path.empty?
-      @api_endpoint.path = @api_endpoint.path.chop if @api_endpoint.path.end_with? '/'
+      @api_endpoint.path = @api_endpoint.path.chop if @api_endpoint.path.end_with?('/')
       components = @api_endpoint.path.to_s.split('/') # ["", "api"] or ["", "apis", batch]
       @api_group = components.length > 2 ? components[2] + '/' : ''
     end
@@ -155,28 +154,11 @@ module Kubeclient
       namespace.to_s.empty? ? '' : "namespaces/#{namespace}/"
     end
 
-    def self.resource_class(class_owner, entity_type)
-      if class_owner.const_defined?(entity_type, false)
-        class_owner.const_get(entity_type, false)
-      else
-        class_owner.const_set(
-          entity_type,
-          Class.new(RecursiveOpenStruct) do
-            def initialize(hash = nil, args = {})
-              args[:recurse_over_arrays] = true
-              super(hash, args)
-            end
-          end
-        )
-      end
-    end
-
     def define_entity_methods
       @entities.values.each do |entity|
-        klass = ClientMixin.resource_class(@class_owner, entity.entity_type)
         # get all entities of a type e.g. get_nodes, get_pods, etc.
         define_singleton_method("get_#{entity.method_names[1]}") do |options = {}|
-          get_entities(entity.entity_type, klass, entity.resource_name, options)
+          get_entities(entity.entity_type, entity.resource_name, options)
         end
 
         # watch all entities of a type e.g. watch_nodes, watch_pods, etc.
@@ -190,16 +172,17 @@ module Kubeclient
 
         # get a single entity of a specific type by name
         define_singleton_method("get_#{entity.method_names[0]}") \
-            do |name, namespace = nil, opts = {}|
-          get_entity(klass, entity.resource_name, name, namespace, opts)
+        do |name, namespace = nil, opts = {}|
+          get_entity(entity.resource_name, name, namespace, opts)
         end
 
-        define_singleton_method("delete_#{entity.method_names[0]}") do |name, namespace = nil|
-          delete_entity(entity.resource_name, name, namespace)
+        define_singleton_method("delete_#{entity.method_names[0]}") \
+        do |name, namespace = nil, opts = {}|
+          delete_entity(entity.resource_name, name, namespace, opts)
         end
 
         define_singleton_method("create_#{entity.method_names[0]}") do |entity_config|
-          create_entity(entity.entity_type, entity.resource_name, entity_config, klass)
+          create_entity(entity.entity_type, entity.resource_name, entity_config)
         end
 
         define_singleton_method("update_#{entity.method_names[0]}") do |entity_config|
@@ -228,7 +211,7 @@ module Kubeclient
         user: @auth_options[:username],
         password: @auth_options[:password],
         open_timeout: @timeouts[:open],
-        ClientMixin.restclient_read_timeout_option => @timeouts[:read]
+        read_timeout: @timeouts[:read]
       }
       RestClient::Resource.new(@api_endpoint.merge(path).to_s, options)
     end
@@ -245,6 +228,9 @@ module Kubeclient
     #   :label_selector (string) - a selector to restrict the list of returned objects by labels.
     #   :field_selector (string) - a selector to restrict the list of returned objects by fields.
     #   :resource_version (string) - shows changes that occur after passed version of a resource.
+    #   :as (:raw|:ros) - defaults to :ros
+    #     :raw - return the raw response body as a string
+    #     :ros - return a collection of RecursiveOpenStruct objects
     def watch_entities(resource_name, options = {})
       ns = build_namespace_prefix(options[:namespace])
 
@@ -256,68 +242,73 @@ module Kubeclient
       WATCH_ARGUMENTS.each { |k, v| params[k] = options[v] if options[v] }
       uri.query = URI.encode_www_form(params) if params.any?
 
-      Kubeclient::Common::WatchStream.new(uri, http_options(uri))
+      Kubeclient::Common::WatchStream.new(uri, http_options(uri), as: options[:as] || :ros)
     end
 
     # Accepts the following options:
     #   :namespace (string) - the namespace of the entity.
     #   :label_selector (string) - a selector to restrict the list of returned objects by labels.
     #   :field_selector (string) - a selector to restrict the list of returned objects by fields.
-    #   :as (symbol) - if :raw, return the raw response body (as a string)
-    #
-    #   Default response type will return a collection RecursiveOpenStruct
-    #   (:ros) objects, unless `:as` is passed with `:raw`.
-    def get_entities(entity_type, klass, resource_name, options = {})
+    #   :as (:raw|:ros) - defaults to :ros
+    #     :raw - return the raw response body as a string
+    #     :ros - return a collection of RecursiveOpenStruct objects
+    def get_entities(entity_type, resource_name, options = {})
       params = {}
       SEARCH_ARGUMENTS.each { |k, v| params[k] = options[v] if options[v] }
 
       ns_prefix = build_namespace_prefix(options[:namespace])
       response = handle_exception do
         rest_client[ns_prefix + resource_name]
-        .get({ 'params' => params }.merge(@headers))
+          .get({ 'params' => params }.merge(@headers))
       end
       return response.body if options[:as] == :raw
 
       result = JSON.parse(response)
 
-      resource_version = result.fetch('resourceVersion', nil)
-      if resource_version.nil?
-        resource_version =
-            result.fetch('metadata', {}).fetch('resourceVersion', nil)
-      end
+      resource_version =
+        result.fetch('resourceVersion') do
+          result.fetch('metadata', {}).fetch('resourceVersion', nil)
+        end
 
       # result['items'] might be nil due to https://github.com/kubernetes/kubernetes/issues/13096
-      collection = result['items'].to_a.map { |item| new_entity(item, klass) }
+      collection = result['items'].to_a.map { |item| Kubeclient::Resource.new(item) }
 
       Kubeclient::Common::EntityList.new(entity_type, resource_version, collection)
     end
 
     # Accepts the following options:
-    #   :as (symbol) - if :raw, return the raw response body (as a string)
-    #
-    #   Default response type will return an entity as a  RecursiveOpenStruct
-    #   (:ros) object, unless `:as` is passed with `:raw`.
-    def get_entity(klass, resource_name, name, namespace = nil, options = {})
+    #   :as (:raw|:ros) - defaults to :ros
+    #     :raw - return the raw response body as a string
+    #     :ros - return a collection of RecursiveOpenStruct objects
+    def get_entity(resource_name, name, namespace = nil, options = {})
       ns_prefix = build_namespace_prefix(namespace)
       response = handle_exception do
         rest_client[ns_prefix + resource_name + "/#{name}"]
-        .get(@headers)
+          .get(@headers)
       end
-      return response.body if options[:as] == :raw
-
-      result = JSON.parse(response)
-      new_entity(result, klass)
+      format_response(options[:as], response)
     end
 
-    def delete_entity(resource_name, name, namespace = nil)
+    # delete_options are passed as a JSON payload in the delete request
+    def delete_entity(resource_name, name, namespace = nil, delete_options: {})
+      delete_options_hash = delete_options.to_hash
       ns_prefix = build_namespace_prefix(namespace)
-      handle_exception do
-        rest_client[ns_prefix + resource_name + "/#{name}"]
-          .delete(@headers)
+      payload = delete_options_hash.to_json unless delete_options_hash.empty?
+      response = handle_exception do
+        rs = rest_client[ns_prefix + resource_name + "/#{name}"]
+        RestClient::Request.execute(
+          rs.options.merge(
+            method: :delete,
+            url: rs.url,
+            headers: { 'Content-Type' => 'application/json' }.merge(@headers),
+            payload: payload
+          )
+        )
       end
+      format_response(:ros, response)
     end
 
-    def create_entity(entity_type, resource_name, entity_config, klass)
+    def create_entity(entity_type, resource_name, entity_config)
       # Duplicate the entity_config to a hash so that when we assign
       # kind and apiVersion, this does not mutate original entity_config obj.
       hash = entity_config.to_hash
@@ -329,42 +320,35 @@ module Kubeclient
       # https://github.com/GoogleCloudPlatform/kubernetes/issues/6439
       # TODO: #2 solution for
       # https://github.com/kubernetes/kubernetes/issues/8115
-      if entity_type.eql? 'Endpoint'
-        hash[:kind] = 'Endpoints'
-      else
-        hash[:kind] = entity_type
-      end
+      hash[:kind] = (entity_type.eql?('Endpoint') ? 'Endpoints' : entity_type)
       hash[:apiVersion] = @api_group + @api_version
       response = handle_exception do
         rest_client[ns_prefix + resource_name]
-        .post(hash.to_json, { 'Content-Type' => 'application/json' }.merge(@headers))
+          .post(hash.to_json, { 'Content-Type' => 'application/json' }.merge(@headers))
       end
-      result = JSON.parse(response)
-      new_entity(result, klass)
+      format_response(:ros, response)
     end
 
     def update_entity(resource_name, entity_config)
       name      = entity_config[:metadata][:name]
       ns_prefix = build_namespace_prefix(entity_config[:metadata][:namespace])
-      handle_exception do
+      response = handle_exception do
         rest_client[ns_prefix + resource_name + "/#{name}"]
           .put(entity_config.to_h.to_json, { 'Content-Type' => 'application/json' }.merge(@headers))
       end
+      format_response(:ros, response)
     end
 
     def patch_entity(resource_name, name, patch, namespace = nil)
       ns_prefix = build_namespace_prefix(namespace)
-      handle_exception do
+      response = handle_exception do
         rest_client[ns_prefix + resource_name + "/#{name}"]
           .patch(
             patch.to_json,
             { 'Content-Type' => 'application/strategic-merge-patch+json' }.merge(@headers)
           )
       end
-    end
-
-    def new_entity(hash, klass)
-      klass.new(hash)
+      format_response(:ros, response)
     end
 
     def all_entities(options = {})
@@ -375,7 +359,7 @@ module Kubeclient
         method_name = "get_#{entity.method_names[1]}"
         begin
           result_hash[entity.method_names[0]] = send(method_name, options)
-        rescue KubeException
+        rescue Kubeclient::HttpError
           next # do not fail due to resources not supporting get
         end
       end
@@ -405,16 +389,17 @@ module Kubeclient
       uri.path += "/#{@api_version}/#{ns}pods/#{pod_name}/log"
       uri.query = URI.encode_www_form(params)
 
-      Kubeclient::Common::WatchStream.new(uri, http_options(uri), format: :text)
+      Kubeclient::Common::WatchStream.new(uri, http_options(uri), as: :raw)
     end
 
     def proxy_url(kind, name, port, namespace = '')
       discover unless @discovered
-      entity_name_plural = if %w(services pods nodes).include?(kind.to_s)
-                             kind.to_s
-                           else
-                             @entities[kind.to_s].resource_name
-                           end
+      entity_name_plural =
+        if %w[services pods nodes].include?(kind.to_s)
+          kind.to_s
+        else
+          @entities[kind.to_s].resource_name
+        end
       ns_prefix = build_namespace_prefix(namespace)
       # TODO: Change this once services supports the new scheme
       if entity_name_plural == 'pods'
@@ -428,7 +413,7 @@ module Kubeclient
       ns_prefix = build_namespace_prefix(template[:metadata][:namespace])
       response = handle_exception do
         rest_client[ns_prefix + 'processedtemplates']
-        .post(template.to_h.to_json, { 'Content-Type' => 'application/json' }.merge(@headers))
+          .post(template.to_h.to_json, { 'Content-Type' => 'application/json' }.merge(@headers))
       end
       JSON.parse(response)
     end
@@ -436,7 +421,7 @@ module Kubeclient
     def api_valid?
       result = api
       result.is_a?(Hash) && (result['versions'] || []).any? do |group|
-        @api_group.empty? ? group.include?(@api_version) : group['version'] == (@api_version)
+        @api_group.empty? ? group.include?(@api_version) : group['version'] == @api_version
       end
     end
 
@@ -445,26 +430,21 @@ module Kubeclient
       JSON.parse(response)
     end
 
-    def self.restclient_read_timeout_option
-      @restclient_read_timeout_option ||=
-        # RestClient silently accepts unknown options, so check accessors instead.
-        if RestClient::Resource.instance_methods.include?(:read_timeout) # rest-client 2.0
-          :read_timeout
-        elsif RestClient::Resource.instance_methods.include?(:timeout) # rest-client 1.x
-          :timeout
-        else
-          fail ArgumentError("RestClient doesn't support neither :read_timeout nor :timeout")
-        end
-    end
-
     private
 
+    def format_response(as, response)
+      return response.body if as == :raw
+
+      result = JSON.parse(response)
+      Kubeclient::Resource.new(result)
+    end
+
     def load_entities
       @entities = {}
       fetch_entities['resources'].each do |resource|
         next if resource['name'].include?('/')
-        resource['kind'] = Kubeclient::Common::MissingKindCompatibility
-                           .resource_kind(resource['name']) if resource['kind'].nil?
+        resource['kind'] ||=
+          Kubeclient::Common::MissingKindCompatibility.resource_kind(resource['name'])
         entity = ClientMixin.parse_definition(resource['kind'], resource['name'])
         @entities[entity.method_names[0]] = entity if entity
       end
@@ -483,20 +463,23 @@ module Kubeclient
       # maintain backward compatibility:
       opts[:username] = opts[:user] if opts[:user]
 
-      if [:bearer_token, :bearer_token_file, :username].count { |key| opts[key] } > 1
-        fail(ArgumentError, 'Invalid auth options: specify only one of username/password,' \
-             ' bearer_token or bearer_token_file')
-      elsif [:username, :password].count { |key| opts[key] } == 1
-        fail(ArgumentError, 'Basic auth requires both username & password')
+      if %i[bearer_token bearer_token_file username].count { |key| opts[key] } > 1
+        raise(
+          ArgumentError,
+          'Invalid auth options: specify only one of username/password,' \
+          ' bearer_token or bearer_token_file'
+        )
+      elsif %i[username password].count { |key| opts[key] } == 1
+        raise ArgumentError, 'Basic auth requires both username & password'
       end
     end
 
     def validate_bearer_token_file
       msg = "Token file #{@auth_options[:bearer_token_file]} does not exist"
-      fail ArgumentError, msg unless File.file?(@auth_options[:bearer_token_file])
+      raise ArgumentError, msg unless File.file?(@auth_options[:bearer_token_file])
 
       msg = "Cannot read token file #{@auth_options[:bearer_token_file]}"
-      fail ArgumentError, msg unless File.readable?(@auth_options[:bearer_token_file])
+      raise ArgumentError, msg unless File.readable?(@auth_options[:bearer_token_file])
     end
 
     def http_options(uri)