k8s-client-renewed 0.10.5.pre.1

data/lib/k8s/client/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module K8s
+  class Client
+    # Updated on releases using semver.
+    VERSION = "0.10.5-1"
+  end
+end

data/lib/k8s/config.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require 'recursive-open-struct'
+require 'base64'
+require 'yaml'
+require 'time'
+
+module K8s
+  # Common struct type for kubeconfigs:
+  #
+  # * converts string keys to symbols
+  # * normalizes foo-bar to foo_bar
+  # @see https://godoc.org/k8s.io/client-go/tools/clientcmd/api/v1#Config
+  class Config < RecursiveOpenStruct
+    using K8s::Util::HashBackport if RUBY_VERSION < "2.5"
+
+    module KeyTransformations
+      def initialize(hash = self.class.defaults, args = {})
+        super(hash.to_h.transform_keys { |k| k.to_s.tr('-', '_').to_sym }, args.merge(recurse_over_arrays: true))
+      end
+
+      def to_h
+        super.transform_keys { |k| k.to_s.tr('_', '-').to_sym }
+      end
+    end
+
+    class Child < RecursiveOpenStruct
+      include KeyTransformations
+    end
+
+    include KeyTransformations
+
+    def self.defaults
+      {
+        :apiVersion => 'v1',
+        :clusters=> [],
+        :contexts => [],
+        :current_context => nil,
+        :kind => 'Config',
+        :preferences => {},
+        :users => []
+      }
+    end
+
+    # Loads a configuration from a YAML file
+    #
+    # @param path [String]
+    # @return [K8s::Config]
+    def self.load_file(path)
+      new(YAML.safe_load(File.read(File.expand_path(path)), [Time, DateTime, Date], [], true))
+    end
+
+    # Loads configuration files listed in KUBE_CONFIG environment variable and
+    # merge using the configuration merge rules, @see K8s::Config.merge
+    #
+    # @param kubeconfig [String] by default read from ENV['KUBECONFIG']
+    def self.from_kubeconfig_env(kubeconfig = nil)
+      kubeconfig ||= ENV.fetch('KUBECONFIG', '')
+      raise ArgumentError, "KUBECONFIG not set" if kubeconfig.empty?
+
+      paths = kubeconfig.split(/(?!\\):/)
+
+      paths.inject(load_file(paths.shift)) do |memo, other_cfg|
+        memo.merge(load_file(other_cfg))
+      end
+    end
+
+    # Build a minimal configuration from at least a server address, server certificate authority data and an access token.
+    #
+    # @param server [String] kubernetes server address
+    # @param ca [String] server certificate authority data (base64 encoded)
+    # @param token [String] access token
+    # @param cluster_name [String] cluster name
+    # @param user [String] user name
+    # @param context [String] context name
+    # @param options [Hash] (see #initialize)
+    def self.build(server:, ca:, auth_token:, cluster_name: 'kubernetes', user: 'k8s-client', context: 'k8s-client', **options)
+      new(
+        {
+          clusters: [{ name: cluster_name, cluster: { server: server, certificate_authority_data: ca } }],
+          users: [{ name: user, user: { token: auth_token } }],
+          contexts: [{ name: context, context: { cluster: cluster_name, user: user } }],
+          current_context: context
+        }.merge(options)
+      )
+    end
+
+    # Merges configuration according to the rules specified in
+    # https://kubernetes.io/docs/concepts/configuration/organize-cluster-access-kubeconfig/#merging-kubeconfig-files
+    #
+    # @param other [Hash, K8s::Config]
+    # @return [K8s::Config]
+    def merge(other)
+      old_attributes = to_h
+      other_attributes = other.is_a?(Hash) ? other : other.to_h
+
+      old_attributes.merge!(other_attributes) do |key, old_value, new_value|
+        case key
+        when :clusters, :contexts, :users
+          old_value + new_value.reject do |new_mapping|
+            old_value.any? { |old_mapping| old_mapping[:name] == new_mapping[:name] }
+          end
+        else
+          case old_value
+          when Array
+            (old_value + new_value).uniq
+          when Hash
+            old_value.merge(new_value) do |_key, inner_old_value, inner_new_value|
+              inner_old_value.nil? ? inner_new_value : inner_old_value
+            end
+          when NilClass
+            new_value
+          else
+            old_value
+          end
+        end
+      end
+
+      self.class.new(old_attributes)
+    end
+
+    # @param name [String]
+    # @raise [K8s::Error::Configuration]
+    # @return [K8s::Config::Child]
+    def context(name = current_context)
+      return nil if name.nil?
+
+      contexts.find { |context| context.name == name }&.context || raise(K8s::Error::Configuration, "context not found: #{name.inspect}")
+    end
+
+    # @param name [String]
+    # @raise [K8s::Error::Configuration]
+    # @return [K8s::Config::Child]
+    def cluster(name = context&.cluster)
+      return nil if name.nil?
+
+      clusters.find { |cluster| cluster.name == name }&.cluster || raise(K8s::Error::Configuration, "cluster not found: #{name.inspect}")
+    end
+
+    # @param name [String]
+    # @raise [K8s::Error::Configuration]
+    # @return [K8s::Config::User]
+    def user(name = context&.user)
+      return nil if name.nil?
+
+      users.find { |user| user.name == name }&.user || raise(K8s::Error::Configuration, "user not found: #{name.inspect}")
+    end
+
+    private
+
+    # Patch the RecursiveOpenStruct#recurse_over_array method to use a different child class
+    def recurse_over_array(array)
+      array.each_with_index do |a, i|
+        if a.is_a?(Hash)
+          array[i] = Child.new(
+            a,
+            recurse_over_arrays: true,
+            mutate_input_hash: true,
+            preserve_original_keys: @preserve_original_keys
+          )
+        elsif a.is_a?(Array)
+          array[i] = recurse_over_array(a)
+        end
+      end
+      array
+    end
+  end
+end

data/lib/k8s/error.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module K8s
+  # Top-level class for all errors raised by this gem.
+  class Error < StandardError
+    # Kube API error, related to a HTTP response with a non-2xx code
+    class API < Error
+      extend Forwardable
+
+      attr_reader :method, :path, :code, :reason, :status
+
+      # @param method [Integer] HTTP request method
+      # @param path [Integer] HTTP request path
+      # @param code [Integer] HTTP response code
+      # @param reason [String] HTTP response reason
+      # @param status [K8s::API::MetaV1::Status]
+      def initialize(method, path, code, reason, status = nil)
+        @method = method
+        @path = path
+        @code = code
+        @reason = reason
+        @status = status
+
+        if status
+          super("#{@method} #{@path} => HTTP #{@code} #{@reason}: #{@status.message}")
+        else
+          super("#{@method} #{@path} => HTTP #{@code} #{@reason}")
+        end
+      end
+    end
+
+    BadRequest = Class.new(API).freeze
+    Unauthorized = Class.new(API).freeze
+    Forbidden = Class.new(API).freeze
+    NotFound = Class.new(API).freeze
+    MethodNotAllowed = Class.new(API).freeze
+    Conflict = Class.new(API).freeze # XXX: also AlreadyExists?
+    Invalid = Class.new(API).freeze
+    Timeout = Class.new(API).freeze
+    InternalError = Class.new(API).freeze
+    ServiceUnavailable = Class.new(API).freeze
+    ServerTimeout = Class.new(API).freeze
+
+    HTTP_STATUS_ERRORS = {
+      400 => BadRequest,
+      401 => Unauthorized,
+      403 => Forbidden,
+      404 => NotFound,
+      405 => MethodNotAllowed,
+      409 => Conflict,
+      422 => Invalid,
+      429 => Timeout,
+      500 => InternalError,
+      503 => ServiceUnavailable,
+      504 => ServerTimeout
+    }.freeze
+
+    # Attempt to create a ResourceClient for an unknown resource type.
+    # The client cannot construct the correct API URL without having the APIResource definition.
+    UndefinedResource = Class.new(Error)
+
+    Configuration = Class.new(Error)
+  end
+end

data/lib/k8s/json_parser.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module K8s
+  module JSONParser
+    # Standard library JSON -based JSON-parsing backend
+    class Default
+      # A simple buffer that accepts data through the `<<` method and yields its buffer when a
+      # newline character is encountered.
+      class LineBufferedIO
+        def initialize(&block)
+          @buffer = +''
+          @parser = block
+        end
+
+        # @param data [String] partial JSON content
+        def <<(data)
+          chunks = data.rpartition("\n")
+          tail = chunks.pop
+          @buffer << chunks.join
+
+          if @buffer.include?("\n")
+            @buffer.each_line do |line|
+              @parser.call(line) unless line.strip.empty?
+            end
+
+            @buffer.clear
+          end
+
+          @buffer << tail
+        end
+      end
+
+      # @param input [String] JSON content
+      # @return [Hash,Array,String,Integer,Float,DateTime] the parsed result
+      def self.parse(input)
+        JSON.parse(input)
+      end
+
+      # Instantiate a streaming parser.
+      #
+      # @example
+      #   result = []
+      #   parser = K8s::JSONParser::Default.new do |obj|
+      #     result << obj
+      #   end
+      #   parser << '{"hello":"world"\n}'
+      #   parser << '{"hello":"world"\n}'
+      #   puts result.inspect
+      #   # outputs:
+      #   # [{ 'hello' => 'world' }, { 'hello' => 'world' }]
+      def initialize(&block)
+        @parser = LineBufferedIO.new do |data|
+          block.call(JSON.parse(data))
+        end
+      end
+
+      def <<(data)
+        @parser << data
+      end
+    end
+
+    def self.backend
+      @backend ||= Default
+    end
+
+    # @param parser_class [Class] set a different JSON parser backend
+    def self.backend=(parser_class)
+      @backend = parser_class
+    end
+
+    # @param input [String] JSON content
+    # @return [Object] parse outcome
+    def self.parse(input)
+      backend.parse(input)
+    end
+
+
+    # Instantiate a streaming JSON parser.
+    #
+    # @example
+    #   result = []
+    #   parser = K8s::JSONParser.new do |obj|
+    #     result << obj
+    #   end
+    #   parser << '{"hello":"world"\n}'
+    #   parser << '{"hello":"world"\n}'
+    #   puts result.inspect
+    #   # outputs:
+    #   # [{ 'hello' => 'world' }, { 'hello' => 'world' }]
+    # @return [K8s::JSONParser::Default,K8s::JSONParser::Yajl]
+    def self.new(&block)
+      backend.new(&block)
+    end
+  end
+end

data/lib/k8s/json_parser/yajl.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'yajl'
+
+module K8s
+  module JSONParser
+    # Yajl JSON-parsing backend, with the native extension it's faster than the pure-ruby standard library JSON-parser.
+    #
+    # To use install, add `gem 'yajl-ruby'` to your gemfile and require this class: `require 'k8s/json_parser/yajl'`
+    class Yajl
+      # @param input [String] JSON content
+      # @return [Hash,Array,String,Integer,Float,DateTime] the parsed result
+      def self.parse(input)
+        ::Yajl::Parser.parse(input)
+      end
+
+      # Instantiate a streaming parser.
+      #
+      # @example
+      #   result = []
+      #   parser = K8s::JSONParser::Yajl.new do |obj|
+      #     result << obj
+      #   end
+      #   parser << '{"hello":"world"\n}'
+      #   parser << '{"hello":"world"\n}'
+      #   puts result.inspect
+      #   # outputs:
+      #   # [{ 'hello' => 'world' }, { 'hello' => 'world' }]
+      def initialize(&block)
+        @parser = ::Yajl::Parser.new.tap do |parser|
+          parser.on_parse_complete = block
+        end
+      end
+
+      # The block passed to #new will be executed for each complete document
+      # @param data [String] partial JSON content
+      def <<(data)
+        @parser << data
+      end
+    end
+  end
+end
+
+K8s::JSONParser.backend = K8s::JSONParser::Yajl

data/lib/k8s/logging.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module K8s
+  # Logging utilities
+  #
+  # This provides a per-class Logger that uses the class name as a logging prefix.
+  # Instances can optionally also use logger! to define a per-instance Logger using a custom prefix.
+  module Logging
+    # Default log target
+    LOG_TARGET = $stderr
+
+    # Default log level: show warnings.
+    #
+    # Use K8s::Logging.quiet! to supress warnings.
+    # Note that the K8s::Transport defaults to quiet!
+    LOG_LEVEL = Logger::WARN
+
+    # methods defined on both the global K8s::Logging module, as well as class methods on each class including K8s::Logging
+    module ModuleMethods
+      # global log_level shared across all including classes
+      # @return Logger::*
+      def log_level
+        @log_level
+      end
+
+      # @param level Logger::*
+      def log_level=(level)
+        @log_level = level
+      end
+
+      # Set log_level to Logger::DEBUG
+      def debug!
+        self.log_level = Logger::DEBUG
+      end
+
+      # Set log_level to Logger::INFO
+      def verbose!
+        self.log_level = Logger::INFO
+      end
+
+      # Set log_level to Logger::ERROR, surpressing any warnings logged by default
+      def quiet!
+        self.log_level = Logger::ERROR
+      end
+    end
+
+    extend ModuleMethods # global @log_level
+
+    # methods defined on each class including K8s::Logging
+    module ClassMethods
+      # @return [Logger]
+      def logger(target: LOG_TARGET, level: nil)
+        @logger ||= Logger.new(target).tap do |logger|
+          logger.progname = name
+          logger.level = level || log_level || K8s::Logging.log_level || LOG_LEVEL
+        end
+      end
+    end
+
+    # extend class/intance methods for per-class logger
+    def self.included(base)
+      base.extend(ModuleMethods) # per-class @log_level
+      base.extend(ClassMethods)
+    end
+
+    # Use per-instance logger instead of the default per-class logger
+    #
+    # Sets the instance variable returned by #logger
+    #
+    # @return [Logger]
+    def logger!(progname: self.class.name, target: LOG_TARGET, level: nil, debug: false)
+      @logger = Logger.new(target).tap do |logger|
+        level = Logger::DEBUG if debug
+
+        logger.progname = "#{self.class.name}<#{progname}>"
+        logger.level = level || self.class.log_level || K8s::Logging.log_level || LOG_LEVEL
+      end
+    end
+
+    # @return [Logger]
+    def logger
+      @logger || self.class.logger
+    end
+  end
+end