k8s-ruby2 0.10.6

data/lib/k8s/client.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+
+require 'openssl'
+require 'base64'
+require 'yajl'
+require 'monitor'
+require 'uri'
+
+require 'k8s/util'
+
+require 'k8s/api/metav1'
+require 'k8s/api/version'
+require 'k8s/config'
+require 'k8s/logging'
+require 'k8s/api_client'
+require "k8s/error"
+require 'k8s/resource'
+require 'k8s/resource_client'
+require 'k8s/stack'
+require 'k8s/transport'
+
+module K8s
+  # @param server [String] http/s URL
+  # @param options [Hash] @see Transport.new
+  # @return [K8s::Client]
+  def self.client(server, **options)
+    Client.new(Transport.new(server, **options))
+  end
+
+  # Top-level client wrapper.
+  # Uses a {Transport} instance to talk to the kube API.
+  # Offers access to {APIClient} and {ResourceClient} instances.
+  class Client
+    # @param config [Phraos::Kube::Config]
+    # @param namespace [String] @see #initialize
+    # @param options [Hash] @see Transport.config
+    # @return [K8s::Client]
+    def self.config(config, namespace: nil, **options)
+      new(
+        Transport.config(config, **options),
+        namespace: namespace
+      )
+    end
+
+    # An K8s::Client instance from in-cluster config within a kube pod, using the kubernetes service envs and serviceaccount secrets
+    # @see K8s::Transport#in_cluster_config
+    #
+    # @param namespace [String] default namespace for all operations
+    # @param options [Hash] options passed to transport, @see Transport#in_cluster_config
+    # @return [K8s::Client]
+    # @raise [K8s::Error::Config,Errno::ENOENT,Errno::EACCES]
+    def self.in_cluster_config(namespace: nil, **options)
+      new(Transport.in_cluster_config(**options), namespace: namespace)
+    end
+
+    # Attempts to create a K8s::Client instance automatically using environment variables, existing configuration
+    # files or in cluster configuration.
+    #
+    # Look-up order:
+    #   - KUBE_TOKEN, KUBE_CA, KUBE_SERVER environment variables
+    #   - KUBECONFIG environment variable
+    #   - $HOME/.kube/config file
+    #   - In cluster configuration
+    #
+    # Will raise when no means of configuration is available
+    #
+    # @param options [Hash] default namespace for all operations
+    # @raise [K8s::Error::Config,Errno::ENOENT,Errno::EACCES]
+    # @return [K8s::Client]
+    def self.autoconfig(namespace: nil, **options)
+      if ENV.values_at('KUBE_TOKEN', 'KUBE_CA', 'KUBE_SERVER').none? { |v| v.nil? || v.empty? }
+        unless Base64.decode64(ENV['KUBE_CA']).match?(/CERTIFICATE/)
+          raise ArgumentError, 'KUBE_CA does not seem to be base64 encoded'
+        end
+
+        begin
+          token = options[:auth_token] || Base64.strict_decode64(ENV['KUBE_TOKEN'])
+        rescue ArgumentError
+          raise ArgumentError, 'KUBE_TOKEN does not seem to be base64 encoded'
+        end
+
+        configuration = K8s::Config.build(server: ENV['KUBE_SERVER'], ca: ENV['KUBE_CA'], auth_token: token)
+      elsif !ENV['KUBECONFIG'].to_s.empty?
+        configuration = K8s::Config.from_kubeconfig_env(ENV['KUBECONFIG'])
+      else
+        found_config = [
+          File.join(Dir.home, '.kube', 'config'),
+          '/etc/kubernetes/admin.conf',
+          '/etc/kubernetes/kubelet.conf'
+        ].find { |f| File.exist?(f) && File.readable?(f) }
+
+        configuration = K8s::Config.load_file(found_config) if found_config
+      end
+
+      if configuration
+        config(configuration, namespace: namespace, **options)
+      else
+        in_cluster_config(namespace: namespace, **options)
+      end
+    end
+
+    include MonitorMixin
+
+    attr_reader :transport
+
+    # @param transport [K8s::Transport]
+    # @param namespace [String, nil] default namespace for all operations
+    def initialize(transport, namespace: nil)
+      @transport = transport
+      @namespace = namespace
+
+      @api_clients = {}
+      super()
+    end
+
+    # @raise [K8s::Error]
+    # @return [K8s::API::Version]
+    def version
+      @version ||= @transport.version
+    end
+
+    # @param api_version [String] "group/version" or "version" (core)
+    # @return [APIClient]
+    def api(api_version = 'v1')
+      @api_clients[api_version] ||= APIClient.new(@transport, api_version)
+    end
+
+    # Force-update /apis cache.
+    # Required if creating new CRDs/apiservices.
+    #
+    # @return [Array<String>]
+    def api_groups!
+      synchronize do
+        @api_groups = @transport.get(
+          '/apis',
+          response_class: K8s::API::MetaV1::APIGroupList
+        ).groups.flat_map{ |api_group| api_group.versions.map(&:groupVersion) }
+
+        @api_clients.clear
+      end
+
+      @api_groups
+    end
+
+    # Cached /apis preferred group apiVersions
+    # @return [Array<String>]
+    def api_groups
+      @api_groups || api_groups!
+    end
+
+    # @param api_versions [Array<String>] defaults to all APIs
+    # @param prefetch_resources [Boolean] prefetch any missing api_resources for each api_version
+    # @param skip_missing [Boolean] return APIClient without api_resources? if 404
+    # @return [Array<APIClient>]
+    def apis(api_versions = nil, prefetch_resources: false, skip_missing: false)
+      api_versions ||= ['v1'] + api_groups
+
+      if prefetch_resources
+        # api groups that are missing their api_resources
+        api_paths = api_versions
+                    .uniq
+                    .reject{ |api_version| api(api_version).api_resources? }
+                    .map{ |api_version| APIClient.path(api_version) }
+
+        # load into APIClient.api_resources=
+        begin
+          @transport.gets(*api_paths, response_class: K8s::API::MetaV1::APIResourceList, skip_missing: skip_missing).each do |api_resource_list|
+            api(api_resource_list.groupVersion).api_resources = api_resource_list.resources if api_resource_list
+          end
+        rescue K8s::Error::NotFound, K8s::Error::ServiceUnavailable
+          # kubernetes api is in unstable state
+          # because this is only performance optimization, better to skip prefetch and move on
+        end
+      end
+
+      api_versions.map{ |api_version| api(api_version) }
+    end
+
+    # @param namespace [String, nil]
+    # @return [Array<K8s::ResourceClient>]
+    def resources(namespace: nil)
+      apis(prefetch_resources: true).map { |api|
+        begin
+          api.resources(namespace: namespace)
+        rescue K8s::Error::ServiceUnavailable, K8s::Error::NotFound
+          []
+        end
+      }.flatten
+    end
+
+    # Pipeline list requests for multiple resource types.
+    #
+    # Returns flattened array with mixed resource kinds.
+    #
+    # @param resources [Array<K8s::ResourceClient>] default is all listable resources for api
+    # @param options @see K8s::ResourceClient#list
+    # @return [Array<K8s::Resource>]
+    def list_resources(resources = nil, **options)
+      cached_clients = @api_clients.size.positive?
+      resources ||= self.resources.select(&:list?)
+
+      begin
+        ResourceClient.list(resources, @transport, **options)
+      rescue K8s::Error::NotFound
+        raise unless cached_clients
+
+        cached_clients = false
+        api_groups!
+        retry
+      end
+    end
+
+    # @param resource [K8s::Resource]
+    # @param namespace [String, nil] default if resource is missing namespace
+    # @raise [K8s::Error::NotFound] API Group does not exist
+    # @raise [K8s::Error::UndefinedResource]
+    # @return [K8s::ResourceClient]
+    def client_for_resource(resource, namespace: nil)
+      api(resource.apiVersion).client_for_resource(resource, namespace: namespace)
+    end
+
+    # @param resource [K8s::Resource]
+    # @return [K8s::Resource]
+    def create_resource(resource)
+      client_for_resource(resource).create_resource(resource)
+    end
+
+    # @param resource [K8s::Resource]
+    # @return [K8s::Resource]
+    def get_resource(resource)
+      client_for_resource(resource).get_resource(resource)
+    end
+
+    # Returns nils for any resources that do not exist.
+    # This includes custom resources that were not yet defined.
+    #
+    # @param resources [Array<K8s::Resource>]
+    # @return [Array<K8s::Resource, nil>] matching resources array 1:1
+    def get_resources(resources)
+      # prefetch api resources, skip missing APIs
+      resource_apis = apis(resources.map(&:apiVersion), prefetch_resources: true, skip_missing: true)
+
+      # map each resource to excon request options, or nil if resource is not (yet) defined
+      requests = resources.zip(resource_apis).map{ |resource, api_client|
+        next nil unless api_client.api_resources?
+
+        resource_client = api_client.client_for_resource(resource)
+
+        {
+          method: 'GET',
+          path: resource_client.path(resource.metadata.name, namespace: resource.metadata.namespace),
+          response_class: resource_client.resource_class
+        }
+      }
+
+      # map non-nil requests to response objects, or nil for nil request options
+      Util.compact_map(requests) { |reqs|
+        @transport.requests(*reqs, skip_missing: true)
+      }
+    end
+
+    # @param resource [K8s::Resource]
+    # @return [K8s::Resource]
+    def update_resource(resource)
+      client_for_resource(resource).update_resource(resource)
+    end
+
+    # @param resource [K8s::Resource]
+    # @param options [Hash]
+    # @see ResourceClient#delete for options
+    # @return [K8s::Resource]
+    def delete_resource(resource, **options)
+      client_for_resource(resource).delete_resource(resource, **options)
+    end
+
+    # @param resource [K8s::Resource]
+    # @param attrs [Hash]
+    # @return [K8s::Client]
+    def patch_resource(resource, attrs)
+      client_for_resource(resource).json_patch(resource.metadata.name, attrs)
+    end
+  end
+end

data/lib/k8s/config.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require 'dry-struct'
+require 'dry-types'
+require 'base64'
+require 'yaml'
+
+module K8s
+  # Common struct type for kubeconfigs:
+  #
+  # * converts string keys to symbols
+  # * normalizes foo-bar to foo_bar
+  class ConfigStruct < Dry::Struct
+    transform_keys do |key|
+      case key
+      when String
+        key.tr('-', '_').to_sym
+      else
+        key
+      end
+    end
+  end
+
+  # @see https://godoc.org/k8s.io/client-go/tools/clientcmd/api/v1#Config
+  class Config < ConfigStruct
+    # Common dry-types for config
+    class Types
+      include Dry::Types()
+    end
+
+    # structured cluster
+    class Cluster < ConfigStruct
+      attribute :server, Types::String
+      attribute :insecure_skip_tls_verify,
+                Types::Bool.optional.default(nil, shared: true)
+      attribute :certificate_authority,
+                Types::String.optional.default(nil, shared: true)
+      attribute :certificate_authority_data,
+                Types::String.optional.default(nil, shared: true)
+      attribute :extensions,
+                Types::Strict::Array.optional.default(nil, shared: true)
+    end
+
+    # structured cluster with name
+    class NamedCluster < ConfigStruct
+      attribute :name, Types::String
+      attribute :cluster, Cluster
+    end
+
+    # structured user auth provider
+    class UserAuthProvider < ConfigStruct
+      attribute :name, Types::String
+      attribute :config, Types::Strict::Hash
+    end
+
+    # structured user exec
+    class UserExec < ConfigStruct
+      attribute :command, Types::String
+      attribute :apiVersion, Types::String
+      attribute :env, Types::Strict::Array.of(Types::Hash).optional.default(nil)
+      attribute :args, Types::Strict::Array.of(Types::String).optional.default(nil, shared: true)
+    end
+
+    # structured user
+    class User < ConfigStruct
+      attribute :client_certificate, Types::String.optional.default(nil, shared: true)
+      attribute :client_certificate_data, Types::String.optional.default(nil, shared: true)
+      attribute :client_key, Types::String.optional.default(nil, shared: true)
+      attribute :client_key_data, Types::String.optional.default(nil, shared: true)
+      attribute :token, Types::String.optional.default(nil, shared: true)
+      attribute :tokenFile, Types::String.optional.default(nil, shared: true)
+      attribute :as, Types::String.optional.default(nil, shared: true)
+      attribute :as_groups, Types::Array.of(Types::String).optional.default(nil, shared: true)
+      attribute :as_user_extra, Types::Hash.optional.default(nil, shared: true)
+      attribute :username, Types::String.optional.default(nil, shared: true)
+      attribute :password, Types::String.optional.default(nil, shared: true)
+      attribute :auth_provider, UserAuthProvider.optional.default(nil, shared: true)
+      attribute :exec, UserExec.optional.default(nil, shared: true)
+      attribute :extensions, Types::Strict::Array.optional.default(nil, shared: true)
+    end
+
+    # structured user with name
+    class NamedUser < ConfigStruct
+      attribute :name, Types::String
+      attribute :user, User
+    end
+
+    # structured context
+    #
+    # Referrs to other named User/cluster objects within the same config.
+    class Context < ConfigStruct
+      attribute :cluster, Types::Strict::String
+      attribute :user, Types::Strict::String
+      attribute :namespace, Types::Strict::String.optional.default(nil, shared: true)
+      attribute :extensions, Types::Strict::Array.optional.default(nil, shared: true)
+    end
+
+    # named context
+    class NamedContext < ConfigStruct
+      attribute :name, Types::String
+      attribute :context, Context
+    end
+
+    attribute :kind, Types::Strict::String.optional.default(nil, shared: true)
+    attribute :apiVersion, Types::Strict::String.optional.default(nil, shared: true)
+    attribute :preferences, Types::Strict::Hash.optional.default(proc { {} }, shared: true)
+    attribute :clusters, Types::Strict::Array.of(NamedCluster).optional.default(proc { [] }, shared: true)
+    attribute :users, Types::Strict::Array.of(NamedUser).optional.default(proc { [] }, shared: true)
+    attribute :contexts, Types::Strict::Array.of(NamedContext).optional.default(proc { [] }, shared: true)
+    attribute :current_context, Types::Strict::String.optional.default(nil, shared: true)
+    attribute :extensions, Types::Strict::Array.optional.default(proc { [] }, shared: true)
+
+    # 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 = attributes
+      other_attributes = other.is_a?(Hash) ? other : other.attributes
+
+      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::Context]
+    def context(name = current_context)
+      found = contexts.find{ |context| context.name == name }
+      raise K8s::Error::Configuration, "context not found: #{name.inspect}" unless found
+
+      found.context
+    end
+
+    # @param name [String]
+    # @return [K8s::Config::Cluster]
+    def cluster(name = context.cluster)
+      clusters.find{ |cluster| cluster.name == name }.cluster
+    end
+
+    # @param name [String]
+    # @return [K8s::Config::User]
+    def user(name = context.user)
+      users.find{ |user| user.name == name }.user
+    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/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