k8s-client 0.4.2 → 0.5.0

data/lib/k8s/logging.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'logger'
 
 module K8s
@@ -51,8 +53,8 @@ module K8s
       # @return [Logger]
       def logger(target: LOG_TARGET, level: nil)
         @logger ||= Logger.new(target).tap do |logger|
-          logger.progname = self.name
-          logger.level = level || self.log_level || K8s::Logging.log_level || LOG_LEVEL
+          logger.progname = name
+          logger.level = level || log_level || K8s::Logging.log_level || LOG_LEVEL
         end
       end
     end

data/lib/k8s/resource.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'deep_merge'
 require 'recursive-open-struct'
 require 'hashdiff'
@@ -11,7 +13,7 @@ module K8s
     # @param data [Hash]
     # @return [self]
     def self.from_json(data)
-      return new(data)
+      new(data)
     end
 
     # @param filename [String] file path
@@ -27,9 +29,9 @@ module K8s
 
       if stat.directory?
         # recurse
-        Dir.glob("#{path}/*.{yml,yaml}").sort.map { |dir| self.from_files(dir) }.flatten
+        Dir.glob("#{path}/*.{yml,yaml}").sort.map { |dir| from_files(dir) }.flatten
       else
-        ::YAML.load_stream(File.read(path), path).map{|doc| new(doc) }
+        ::YAML.load_stream(File.read(path), path).map{ |doc| new(doc) }
       end
     end
 
@@ -67,7 +69,7 @@ module K8s
     end
 
     def checksum
-      @checksum ||= Digest::MD5.hexdigest(Marshal::dump(to_hash))
+      @checksum ||= Digest::MD5.hexdigest(Marshal.dump(to_hash))
     end
 
     def merge_patch_ops(attrs, config_annotation)
@@ -78,7 +80,7 @@ module K8s
     #
     # @return [Hash]
     def current_config(config_annotation)
-      current_cfg = self.metadata.annotations&.dig(config_annotation)
+      current_cfg = metadata.annotations&.dig(config_annotation)
       return {} unless current_cfg
 
       current_hash = JSON.parse(current_cfg)
@@ -89,11 +91,11 @@ module K8s
     end
 
     def can_patch?(config_annotation)
-      !!self.metadata.annotations&.dig(config_annotation)
+      !!metadata.annotations&.dig(config_annotation)
     end
 
     def stringify_hash(hash)
-      JSON.load(JSON.dump(hash))
+      JSON.parse(JSON.dump(hash))
     end
   end
 end

data/lib/k8s/resource_client.rb

@@ -1,9 +1,10 @@
+# frozen_string_literal: true
+
 module K8s
   # Per-APIResource type client.
   #
   # Used to get/list/update/patch/delete specific types of resources, optionally in some specific namespace.
   class ResourceClient
-
     # Common helpers used in both class/instance methods
     module Utils
       # @param selector [nil, String, Hash{String => String}]
@@ -15,7 +16,7 @@ module K8s
         when String
           selector
         when Hash
-          selector.map{|k, v| "#{k}=#{v}"}.join ','
+          selector.map{ |k, v| "#{k}=#{v}" }.join ','
         else
           fail "Invalid selector type. #{selector.inspect}"
         end
@@ -47,17 +48,18 @@ module K8s
     # @param skip_forbidden [Boolean] skip resources that return HTTP 403 errors
     # @return [Array<K8s::Resource>]
     def self.list(resources, transport, namespace: nil, labelSelector: nil, fieldSelector: nil, skip_forbidden: false)
-      api_paths = resources.map{|resource| resource.path(namespace: namespace) }
-      api_lists = transport.gets(*api_paths,
-         response_class: K8s::API::MetaV1::List,
-         query: make_query(
-           'labelSelector' => selector_query(labelSelector),
-           'fieldSelector' => selector_query(fieldSelector),
-         ),
-         skip_forbidden: skip_forbidden,
-       )
-
-      resources.zip(api_lists).map {|resource, api_list| api_list ? resource.process_list(api_list) : [] }.flatten
+      api_paths = resources.map{ |resource| resource.path(namespace: namespace) }
+      api_lists = transport.gets(
+        *api_paths,
+        response_class: K8s::API::MetaV1::List,
+        query: make_query(
+          'labelSelector' => selector_query(labelSelector),
+          'fieldSelector' => selector_query(fieldSelector)
+        ),
+        skip_forbidden: skip_forbidden
+      )
+
+      resources.zip(api_lists).map { |resource, api_list| api_list ? resource.process_list(api_list) : [] }.flatten
     end
 
     # @param transport [K8s::Transport]
@@ -78,7 +80,7 @@ module K8s
         @subresource = nil
       end
 
-      fail "Resource #{api_resource.name} is not namespaced" if namespace unless api_resource.namespaced
+      fail "Resource #{api_resource.name} is not namespaced" unless api_resource.namespaced || !namespace
     end
 
     # @return [String]
@@ -92,14 +94,10 @@ module K8s
     end
 
     # @return [String, nil]
-    def namespace
-      @namespace
-    end
+    attr_reader :namespace
 
     # @return [String]
-    def resource
-      @resource
-    end
+    attr_reader :resource
 
     # @return [Boolean]
     def subresource?
@@ -107,9 +105,7 @@ module K8s
     end
 
     # @return [String, nil]
-    def subresource
-      @subresource
-    end
+    attr_reader :subresource
 
     # @return [String]
     def kind
@@ -117,9 +113,7 @@ module K8s
     end
 
     # @return [class] K8s::Resource
-    def resource_class
-      @resource_class
-    end
+    attr_reader :resource_class
 
     # @return [Bool]
     def namespaced?
@@ -149,9 +143,9 @@ module K8s
     def create_resource(resource)
       @transport.request(
         method: 'POST',
-        path: self.path(namespace: resource.metadata.namespace),
+        path: path(namespace: resource.metadata.namespace),
         request_object: resource,
-        response_class: @resource_class,
+        response_class: @resource_class
       )
     end
 
@@ -164,8 +158,8 @@ module K8s
     def get(name, namespace: @namespace)
       @transport.request(
         method: 'GET',
-        path: self.path(name, namespace: namespace),
-        response_class: @resource_class,
+        path: path(name, namespace: namespace),
+        response_class: @resource_class
       )
     end
 
@@ -174,8 +168,8 @@ module K8s
     def get_resource(resource)
       @transport.request(
         method: 'GET',
-        path: self.path(resource.metadata.name, namespace: resource.metadata.namespace),
-        response_class: @resource_class,
+        path: path(resource.metadata.name, namespace: resource.metadata.namespace),
+        response_class: @resource_class
       )
     end
 
@@ -187,7 +181,7 @@ module K8s
     # @param list [K8s::API::MetaV1::List]
     # @return [Array<resource_class>]
     def process_list(list)
-      list.items.map {|item|
+      list.items.map { |item|
         # list items omit kind/apiVersion
         @resource_class.new(item.merge('apiVersion' => list.apiVersion, 'kind' => @api_resource.kind))
       }
@@ -199,12 +193,12 @@ module K8s
     def list(labelSelector: nil, fieldSelector: nil, namespace: @namespace)
       list = @transport.request(
         method: 'GET',
-        path: self.path(namespace: namespace),
+        path: path(namespace: namespace),
         response_class: K8s::API::MetaV1::List,
         query: make_query(
           'labelSelector' => selector_query(labelSelector),
-          'fieldSelector' => selector_query(fieldSelector),
-        ),
+          'fieldSelector' => selector_query(fieldSelector)
+        )
       )
       process_list(list)
     end
@@ -219,9 +213,9 @@ module K8s
     def update_resource(resource)
       @transport.request(
         method: 'PUT',
-        path: self.path(resource.metadata.name, namespace: resource.metadata.namespace),
+        path: path(resource.metadata.name, namespace: resource.metadata.namespace),
         request_object: resource,
-        response_class: @resource_class,
+        response_class: @resource_class
       )
     end
 
@@ -238,10 +232,10 @@ module K8s
     def merge_patch(name, obj, namespace: @namespace, strategic_merge: true)
       @transport.request(
         method: 'PATCH',
-        path: self.path(name, namespace: namespace),
+        path: path(name, namespace: namespace),
         content_type: strategic_merge ? 'application/strategic-merge-patch+json' : 'application/merge-patch+json',
         request_object: obj,
-        response_class: @resource_class,
+        response_class: @resource_class
       )
     end
 
@@ -252,10 +246,10 @@ module K8s
     def json_patch(name, ops, namespace: @namespace)
       @transport.request(
         method: 'PATCH',
-        path: self.path(name, namespace: namespace),
+        path: path(name, namespace: namespace),
         content_type: 'application/json-patch+json',
         request_object: ops,
-        response_class: @resource_class,
+        response_class: @resource_class
       )
     end
 
@@ -271,7 +265,7 @@ module K8s
     def delete(name, namespace: @namespace, propagationPolicy: nil)
       @transport.request(
         method: 'DELETE',
-        path: self.path(name, namespace: namespace),
+        path: path(name, namespace: namespace),
         query: make_query(
           'propagationPolicy' => propagationPolicy
         ),
@@ -286,11 +280,11 @@ module K8s
     def delete_collection(namespace: @namespace, labelSelector: nil, fieldSelector: nil, propagationPolicy: nil)
       list = @transport.request(
         method: 'DELETE',
-        path: self.path(namespace: namespace),
+        path: path(namespace: namespace),
         query: make_query(
           'labelSelector' => selector_query(labelSelector),
           'fieldSelector' => selector_query(fieldSelector),
-          'propagationPolicy' => propagationPolicy,
+          'propagationPolicy' => propagationPolicy
         ),
         response_class: K8s::API::MetaV1::List, # XXX: documented as returning Status
       )

data/lib/k8s/stack.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'securerandom'
 
 module K8s
@@ -19,7 +21,7 @@ module K8s
     PRUNE_IGNORE = [
       'v1:ComponentStatus', # apiserver ignores GET /v1/componentstatuses?labelSelector=... and returns all resources
       'v1:Endpoints', # inherits stack label from service, but not checksum annotation
-    ]
+    ].freeze
 
     # @param name [String] unique name for stack
     # @param path [String] load resources from YAML files
@@ -59,23 +61,27 @@ module K8s
     end
 
     # @param resource [K8s::Resource] to apply
-    # @param base_resource [K8s::Resource] preserve existing attributes from base resource
+    # @param base_resource [K8s::Resource] DEPRECATED
     # @return [K8s::Resource]
+    # rubocop:disable Lint/UnusedMethodArgument
     def prepare_resource(resource, base_resource: nil)
-      # XXX: base_resource is not really used anymore, kept for backwards compatibility for a while
+      # TODO: base_resource is not used anymore, kept for backwards compatibility for a while
 
       # calculate checksum  only from the "local" source
       checksum = resource.checksum
 
       # add stack metadata
-      resource.merge(metadata: {
-        labels: { @label => name },
-        annotations: {
-          @checksum_annotation => checksum,
-          @last_config_annotation => resource.to_json
-        },
-      })
+      resource.merge(
+        metadata: {
+          labels: { @label => name },
+          annotations: {
+            @checksum_annotation => checksum,
+            @last_config_annotation => resource.to_json
+          }
+        }
+      )
     end
+    # rubocop:enable Lint/UnusedMethodArgument
 
     # @return [Array<K8s::Resource>]
     def apply(client, prune: true)
@@ -107,14 +113,15 @@ module K8s
     def keep_resource!(resource)
       @keep_resources["#{resource.kind}:#{resource.metadata.name}@#{resource.metadata.namespace}"] = resource.metadata.annotations[@checksum_annotation]
     end
+
     def keep_resource?(resource)
       @keep_resources["#{resource.kind}:#{resource.metadata.name}@#{resource.metadata.namespace}"] == resource.metadata.annotations[@checksum_annotation]
     end
 
     # Delete all stack resources that were not applied
-    def prune(client, keep_resources: , skip_forbidden: true)
+    def prune(client, keep_resources:, skip_forbidden: true)
       # using skip_forbidden: assume we can't create resource types that we are forbidden to list, so we don't need to prune them either
-      client.list_resources(labelSelector: {@label => name}, skip_forbidden: skip_forbidden).sort{ |a,b|
+      client.list_resources(labelSelector: { @label => name }, skip_forbidden: skip_forbidden).sort do |a, b|
         # Sort resources so that namespaced objects are deleted first
         if a.metadata.namespace == b.metadata.namespace
           0
@@ -123,7 +130,7 @@ module K8s
         else
           -1
         end
-      }.each do |resource|
+      end.each do |resource|
         next if PRUNE_IGNORE.include? "#{resource.apiVersion}:#{resource.kind}"
 
         resource_label = resource.metadata.labels ? resource.metadata.labels[@label] : nil
@@ -139,9 +146,10 @@ module K8s
           logger.info "Delete resource #{resource.apiVersion}:#{resource.kind}/#{resource.metadata.name} in namespace #{resource.metadata.namespace}"
           begin
             client.delete_resource(resource, propagationPolicy: 'Background')
-          rescue K8s::Error::NotFound
+          rescue K8s::Error::NotFound => ex
             # assume aliased objects in multiple API groups, like for Deployments
             # alternatively, a custom resource whose definition was already deleted earlier
+            logger.debug { "Ignoring #{ex} : #{ex.message}" }
           end
         end
       end

data/lib/k8s/transport.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require 'excon'
 require 'json'
+require 'jsonpath'
 
 module K8s
   # Excon-based HTTP transport handling request/response body JSON encoding
@@ -11,13 +14,13 @@ module K8s
     # Excon middlewares for requests
     EXCON_MIDDLEWARES = [
       # XXX: necessary? redirected requests omit authz headers?
-      Excon::Middleware::RedirectFollower,
+      Excon::Middleware::RedirectFollower
     ] + Excon.defaults[:middlewares]
 
     # Default request headers
     REQUEST_HEADERS = {
-      'Accept' => 'application/json',
-    }
+      'Accept' => 'application/json'
+    }.freeze
 
     # Construct transport from kubeconfig
     #
@@ -67,6 +70,16 @@ module K8s
         logger.debug "Using config with .user.token=..."
 
         options[:auth_token] = token
+      elsif config.user.auth_provider && auth_provider = config.user.auth_provider.config
+        logger.debug "Using config with .user.auth-provider.name=#{config.user.auth_provider.name}"
+
+        auth_data = `#{auth_provider['cmd-path']} #{auth_provider['cmd-args']}`.strip
+        if auth_provider['token-key']
+          json_path = JsonPath.new(auth_provider['token-key'][1...-1])
+          options[:auth_token] = json_path.first(auth_data)
+        else
+          options[:auth_token] = auth_data
+        end
       end
 
       logger.info "Using config with server=#{server}"
@@ -81,10 +94,11 @@ module K8s
       host = ENV['KUBERNETES_SERVICE_HOST']
       port = ENV['KUBERNETES_SERVICE_PORT_HTTPS']
 
-      new("https://#{host}:#{port}",
+      new(
+        "https://#{host}:#{port}",
         ssl_verify_peer: true,
         ssl_ca_file: '/var/run/secrets/kubernetes.io/serviceaccount/ca.crt',
-        auth_token: File.read('/var/run/secrets/kubernetes.io/serviceaccount/token'),
+        auth_token: File.read('/var/run/secrets/kubernetes.io/serviceaccount/token')
       )
     end
 
@@ -103,7 +117,8 @@ module K8s
 
     # @return [Excon::Connection]
     def excon
-      @excon ||= Excon.new(@server,
+      @excon ||= Excon.new(
+        @server,
         persistent: true,
         middlewares: EXCON_MIDDLEWARES,
         headers: REQUEST_HEADERS,
@@ -145,6 +160,7 @@ module K8s
       if options[:query]
         path += Excon::Utils.query_string(options)
       end
+
       if obj = options[:request_object]
         body = "<#{obj.class.name}>"
       end
@@ -178,11 +194,9 @@ module K8s
           raise K8s::Error::API.new(method, path, response.status, "Invalid JSON response: #{response_data.inspect}")
         end
 
-        if response_class
-          return response_class.from_json(response_data)
-        else
-          return response_data # Hash
-        end
+        return response_data unless response_class
+
+        response_class.from_json(response_data)
       else
         error_class = K8s::Error::HTTP_STATUS_ERRORS[response.status] || K8s::Error::API
 
@@ -208,18 +222,17 @@ module K8s
       t = Time.now - start
 
       obj = parse_response(response, options,
-        response_class: response_class,
-      )
+                           response_class: response_class)
     rescue K8s::Error::API => exc
-      logger.warn { "#{format_request(options)} => HTTP #{exc.code} #{exc.reason} in #{'%.3f' % t}s"}
-      logger.debug { "Request: #{excon_options[:body]}"} if excon_options[:body]
-      logger.debug { "Response: #{response.body}"}
+      logger.warn { "#{format_request(options)} => HTTP #{exc.code} #{exc.reason} in #{'%.3f' % t}s" }
+      logger.debug { "Request: #{excon_options[:body]}" } if excon_options[:body]
+      logger.debug { "Response: #{response.body}" }
       raise
     else
-      logger.info { "#{format_request(options)} => HTTP #{response.status}: <#{obj.class}> in #{'%.3f' % t}s"}
-      logger.debug { "Request: #{excon_options[:body]}"} if excon_options[:body]
-      logger.debug { "Response: #{response.body}"}
-      return obj
+      logger.info { "#{format_request(options)} => HTTP #{response.status}: <#{obj.class}> in #{'%.3f' % t}s" }
+      logger.debug { "Request: #{excon_options[:body]}" } if excon_options[:body]
+      logger.debug { "Response: #{response.body}" }
+      obj
     end
 
     # @param options [Array<Hash>] @see #request
@@ -233,46 +246,39 @@ module K8s
 
       start = Time.now
       responses = excon.requests(
-        options.map{|options| request_options(**common_options.merge(options))}
+        options.map{ |opts| request_options(**common_options.merge(opts)) }
       )
       t = Time.now - start
 
-      objects = responses.zip(options).map{|response, request_options|
+      objects = responses.zip(options).map{ |response, request_options|
         response_class = request_options[:response_class] || common_options[:response_class]
 
         begin
           parse_response(response, request_options,
-            response_class: response_class,
-          )
+                         response_class: response_class)
         rescue K8s::Error::NotFound
-          if skip_missing
-            nil
-          else
-            raise
-          end
+          raise unless skip_missing
+
+          nil
         rescue K8s::Error::Forbidden
-          if skip_forbidden
-            nil
-          else
-            raise
-          end
+          raise unless skip_forbidden
+
+          nil
         rescue K8s::Error::ServiceUnavailable => exc
-          if retry_errors
-            logger.warn { "Retry #{format_request(request_options)} => HTTP #{exc.code} #{exc.reason} in #{'%.3f' % t}s" }
-
-            # only retry the failed request, not the entire pipeline
-            request(response_class: response_class, **common_options.merge(request_options))
-          else
-            raise
-          end
+          raise unless retry_errors
+
+          logger.warn { "Retry #{format_request(request_options)} => HTTP #{exc.code} #{exc.reason} in #{'%.3f' % t}s" }
+
+          # only retry the failed request, not the entire pipeline
+          request(response_class: response_class, **common_options.merge(request_options))
         end
       }
     rescue K8s::Error => exc
-      logger.warn { "[#{options.map{|o| format_request(o)}.join ', '}] => HTTP #{exc.code} #{exc.reason} in #{'%.3f' % t}s"}
+      logger.warn { "[#{options.map{ |o| format_request(o) }.join ', '}] => HTTP #{exc.code} #{exc.reason} in #{'%.3f' % t}s" }
       raise
     else
-      logger.info { "[#{options.map{|o| format_request(o)}.join ', '}] => HTTP [#{responses.map{|r| r.status}.join ', '}] in #{'%.3f' % t}s" }
-      return objects
+      logger.info { "[#{options.map{ |o| format_request(o) }.join ', '}] => HTTP [#{responses.map(&:status).join ', '}] in #{'%.3f' % t}s" }
+      objects
     end
 
     # @param path [Array<String>] @see #path
@@ -281,17 +287,20 @@ module K8s
       request(
         method: 'GET',
         path: self.path(*path),
-        **options,
+        **options
       )
     end
 
     # @param paths [Array<String>]
     # @param options [Hash] @see #request
     def gets(*paths, **options)
-      requests(*paths.map{|path| {
-          method: 'GET',
-          path: self.path(path),
-        } },
+      requests(
+        *paths.map do |path|
+          {
+            method: 'GET',
+            path: self.path(path)
+          }
+        end,
         **options
       )
     end