k8s-client 0.1.0

data/lib/k8s/client/version.rb

@@ -0,0 +1,5 @@
+module K8s
+  class Client
+    VERSION = "0.1.0"
+  end
+end

data/lib/k8s/config.rb

@@ -0,0 +1,100 @@
+require 'dry-struct'
+require 'dry-types'
+require 'yaml'
+
+module K8s
+  class ConfigStruct < Dry::Struct
+    # convert string keys to symbols
+    # normalize foo-bar to foo_bar
+    transform_keys do |key|
+      case key
+      when String
+        key.gsub('-', '_').to_sym
+      else
+        key
+      end
+    end
+  end
+
+  # @see https://godoc.org/k8s.io/client-go/tools/clientcmd/api/v1#Config
+  class Config < ConfigStruct
+    class Types
+      include Dry::Types.module
+    end
+
+    class Cluster < ConfigStruct
+      attribute :server, Types::String
+      attribute :insecure_skip_tls_verify, Types::Bool.optional.default(nil)
+      attribute :certificate_authority, Types::String.optional.default(nil)
+      attribute :certificate_authority_data, Types::String.optional.default(nil)
+      attribute :extensions, Types::Strict::Array.optional.default(nil)
+    end
+    class NamedCluster < ConfigStruct
+      attribute :name, Types::String
+      attribute :cluster, Cluster
+    end
+
+    class User < ConfigStruct
+      attribute :client_certificate, Types::String.optional.default(nil)
+      attribute :client_certificate_data, Types::String.optional.default(nil)
+      attribute :client_key, Types::String.optional.default(nil)
+      attribute :client_key_data, Types::String.optional.default(nil)
+      attribute :token, Types::String.optional.default(nil)
+      attribute :tokenFile, Types::String.optional.default(nil)
+      attribute :as, Types::String.optional.default(nil)
+      attribute :as_groups, Types::Array.of(Types::String).optional.default(nil)
+      attribute :as_user_extra, Types::Hash.optional.default(nil)
+      attribute :username, Types::String.optional.default(nil)
+      attribute :password, Types::String.optional.default(nil)
+      attribute :auth_provider, Types::Strict::Hash.optional.default(nil)
+      attribute :exec, Types::Strict::Hash.optional.default(nil)
+      attribute :extensions, Types::Strict::Array.optional.default(nil)
+    end
+    class NamedUser < ConfigStruct
+      attribute :name, Types::String
+      attribute :user, User
+    end
+
+    class Context < ConfigStruct
+      attribute :cluster, Types::Strict::String
+      attribute :user, Types::Strict::String
+      attribute :namespace, Types::Strict::String.optional.default(nil)
+      attribute :extensions, Types::Strict::Array.optional.default(nil)
+    end
+    class NamedContext < ConfigStruct
+      attribute :name, Types::String
+      attribute :context, Context
+    end
+
+    attribute :kind, Types::Strict::String.optional.default(nil)
+    attribute :apiVersion, Types::Strict::String.optional.default(nil)
+    attribute :preferences, Types::Strict::Hash.optional
+    attribute :clusters, Types::Strict::Array.of(NamedCluster)
+    attribute :users, Types::Strict::Array.of(NamedUser)
+    attribute :contexts, Types::Strict::Array.of(NamedContext)
+    attribute :current_context, Types::Strict::String
+    attribute :extensions, Types::Strict::Array.optional.default(nil)
+
+    # @param path [String]
+    # @return [K8s::Config]
+    def self.load_file(path)
+      return new(YAML.load_file(path))
+    end
+
+    # TODO: raise error if not found
+    # @return [K8s::Config::Context]
+    def context(name = current_context)
+      contexts.find{|context| context.name == name}.context
+    end
+
+    # @return [K8s::Config::Cluster]
+    def cluster(name = context.cluster)
+      clusters.find{|cluster| cluster.name == name}.cluster
+    end
+
+    # @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,47 @@
+require 'forwardable'
+
+module K8s
+  class Error < StandardError
+    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
+
+    HTTP_STATUS_ERRORS = {}
+
+    def self.define_status_error(code, name)
+      HTTP_STATUS_ERRORS[code] = self.const_set(name, Class.new(API))
+    end
+
+    define_status_error 400, :BadRequest
+    define_status_error 401, :Unauthorized
+    define_status_error 403, :Forbidden
+    define_status_error 404, :NotFound
+    define_status_error 405, :MethodNotAllowed
+    define_status_error 409, :Conflict # XXX: also AlreadyExists?
+    define_status_error 422, :Invalid
+    define_status_error 429, :Timeout
+    define_status_error 500, :InternalError
+    define_status_error 504, :ServerTimeout
+  end
+end

data/lib/k8s/logging.rb

@@ -0,0 +1,58 @@
+require 'logger'
+
+module K8s
+  module Logging
+    LOG_TARGET = STDERR
+    LOG_LEVEL = Logger::WARN
+
+    module ModuleMethods
+      # global log_level shared across all including classes
+      def log_level
+        @log_level
+      end
+      def log_level=(level)
+        @log_level = level
+      end
+      def debug!
+        self.log_level = Logger::DEBUG
+      end
+      def verbose!
+        self.log_level = Logger::INFO
+      end
+      def quiet!
+        self.log_level = Logger::ERROR
+      end
+    end
+
+    extend ModuleMethods # global @log_level
+
+    module ClassMethods
+      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
+        end
+      end
+    end
+
+    def self.included(base)
+      base.extend(ModuleMethods) # per-class @log_level
+      base.extend(ClassMethods)
+    end
+
+    # Use per-instance 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

data/lib/k8s/resource.rb

@@ -0,0 +1,67 @@
+require 'deep_merge'
+require 'recursive-open-struct'
+
+module K8s
+  # generic untyped resource
+  class Resource < RecursiveOpenStruct
+    extend Forwardable
+    include Comparable
+
+    # @param data [Hash]
+    # @return [self]
+    def self.from_json(data)
+      return new(data)
+    end
+
+    # @param filename [String] file path
+    # @return [K8s::Resource]
+    def self.from_file(filename)
+      new(YAML.load_file(filename))
+    end
+
+    # @param filename [String] file path
+    # @return [Array<K8s::Resource>]
+    def self.from_files(path)
+      stat = File.stat(path)
+
+      if stat.directory?
+        Dir.glob("#{path}/*.{yml,yaml}").map{|path| self.load_files(path) }.flatten
+      else
+        ::YAML.load_stream(File.read(path), path).map{|doc| new(doc) }
+      end
+    end
+
+    # @param attrs [Hash]
+    def initialize(hash, recurse_over_arrays: true, **options)
+      super(hash,
+        recurse_over_arrays: recurse_over_arrays,
+        **options
+      )
+    end
+
+    # @return [String]
+    def to_json(**options)
+      to_hash.to_json(**options)
+    end
+
+    # @param other [K8s::Resource]
+    # @return [Boolean]
+    def <=>(other)
+      to_hash <=> other.to_hash
+    end
+
+    # merge in fields
+    #
+    # @param attrs [Hash, K8s::Resource]
+    # @return [K8s::Resource]
+    def merge(attrs)
+      # deep clone of attrs
+      h = to_hash
+
+      # merge in-place
+      h.deep_merge!(attrs.to_hash, overwrite_arrays: true)
+
+      self.class.new(h)
+    end
+  end
+end

data/lib/k8s/resource_client.rb

@@ -0,0 +1,259 @@
+module K8s
+  class ResourceClient
+    module Utils
+      # @param selector [nil, String, Hash{String => String}]
+      # @return [nil, String]
+      def selector_query(selector)
+        case selector
+        when nil
+          nil
+        when String
+          selector
+        when Hash
+          selector.map{|k, v| "#{k}=#{v}"}.join ','
+        else
+          fail "Invalid selector type. #{selector.inspect}"
+        end
+      end
+
+      # @param options [Hash]
+      # @return [Hash, nil]
+      def make_query(options)
+        query = options.compact
+
+        return nil if query.empty?
+
+        query
+      end
+    end
+
+    include Utils
+    extend Utils
+
+    # Pipeline list requests for multiple resource types.
+    #
+    # Returns flattened array with mixed resource kinds.
+    #
+    # @param resources [Array<K8s::ResourceClient>]
+    # @param transport [K8s::Transport]
+    # @param namespace [String, nil]
+    # @param labelSelector [nil, String, Hash{String => String}]
+    # @param fieldSelector [nil, String, Hash{String => String}]
+    # @return [Array<K8s::Resource>]
+    def self.list(resources, transport, namespace: nil, labelSelector: nil, fieldSelector: nil)
+      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),
+         ),
+       )
+
+      resources.zip(api_lists).map {|resource, api_list| resource.process_list(api_list) }.flatten
+    end
+
+    # @param transport [K8s::Transport]
+    # @param api_client [K8s::APIClient]
+    # @param api_resource [K8s::API::MetaV1::APIResource]
+    # @param namespace [String]
+    def initialize(transport, api_client, api_resource, namespace: nil, resource_class: K8s::Resource)
+      @transport = transport
+      @api_client = api_client
+      @api_resource = api_resource
+      @namespace = namespace
+      @resource_class = resource_class
+
+      if @api_resource.name.include? '/'
+        @resource, @subresource = @api_resource.name.split('/', 2)
+      else
+        @resource = @api_resource.name
+        @subresource = nil
+      end
+
+      fail "Resource #{api_resource.name} is not namespaced" if namespace unless api_resource.namespaced
+    end
+
+    # @return [String]
+    def api_version
+      @api_client.api_version
+    end
+
+    # @return [String] resource or resource/subresource
+    def name
+      @api_resource.name
+    end
+
+    # @return [String, nil]
+    def namespace
+      @namespace
+    end
+
+    # @return [String]
+    def resource
+      @resource
+    end
+
+    # @return [String, nil]
+    def subresource
+      @subresource
+    end
+
+    # @return [String]
+    def kind
+      @api_resource.kind
+    end
+
+    # @return [class] K8s::Resource
+    def resource_class
+      @resource_class
+    end
+
+    # @return [Bool]
+    def namespaced?
+      !!@api_resource.namespaced
+    end
+
+    # @return [String]
+    def path(name = nil, subresource: @subresource, namespace: @namespace)
+      namespace_part = namespace ? ['namespaces', namespace] : []
+
+      if name && subresource
+        @api_client.path(*namespace_part, @resource, name, subresource)
+      elsif name
+        @api_client.path(*namespace_part, @resource, name)
+      else
+        @api_client.path(*namespace_part, @resource)
+      end
+    end
+
+    # @return [Bool]
+    def create?
+      @api_resource.verbs.include? 'create'
+    end
+
+    # @param resource [resource_class] with metadata.namespace and metadata.name set
+    # @return [resource_class]
+    def create_resource(resource)
+      @transport.request(
+        method: 'POST',
+        path: self.path(namespace: resource.metadata.namespace),
+        request_object: resource,
+        response_class: @resource_class,
+      )
+    end
+
+    # @return [Bool]
+    def get?
+      @api_resource.verbs.include? 'get'
+    end
+
+    # @return [resource_class]
+    def get(name, namespace: @namespace)
+      @transport.request(
+        method: 'GET',
+        path: self.path(name, namespace: namespace),
+        response_class: @resource_class,
+      )
+    end
+
+    # @param resource [resource_class]
+    # @return [resource_class]
+    def get_resource(resource)
+      @transport.request(
+        method: 'GET',
+        path: self.path(resource.metadata.name, namespace: resource.metadata.namespace),
+        response_class: @resource_class,
+      )
+    end
+
+    # @return [Bool]
+    def list?
+      @api_resource.verbs.include? 'list'
+    end
+
+    # @param list [K8s::API::MetaV1::List]
+    # @return [Array<resource_class>]
+    def process_list(list)
+      list.items.map {|item|
+        # list items omit kind/apiVersion
+        @resource_class.new(item.merge('apiVersion' => list.apiVersion, 'kind' => @api_resource.kind))
+      }
+    end
+
+    # @param labelSelector [nil, String, Hash{String => String}]
+    # @param fieldSelector [nil, String, Hash{String => String}]
+    # @return [Array<resource_class>]
+    def list(labelSelector: nil, fieldSelector: nil, namespace: @namespace)
+      list = @transport.request(
+        method: 'GET',
+        path: self.path(namespace: namespace),
+        response_class: K8s::API::MetaV1::List,
+        query: make_query(
+          'labelSelector' => selector_query(labelSelector),
+          'fieldSelector' => selector_query(fieldSelector),
+        ),
+      )
+      process_list(list)
+    end
+
+    # @return [Bool]
+    def update?
+      @api_resource.verbs.include? 'update'
+    end
+
+    # @param resource [resource_class] with metadata.resourceVersion set
+    # @return [resource_class]
+    def update_resource(resource)
+      @transport.request(
+        method: 'PUT',
+        path: self.path(resource.metadata.name, namespace: resource.metadata.namespace),
+        request_object: resource,
+        response_class: @resource_class,
+      )
+    end
+
+    # @return [Bool]
+    def delete?
+      @api_resource.verbs.include? 'delete'
+    end
+
+    # @param name [String]
+    # @param namespace [String]
+    # @return [K8s::API::MetaV1::Status]
+    def delete(name, namespace: @namespace, propagationPolicy: nil)
+      @transport.request(
+        method: 'DELETE',
+        path: self.path(name, namespace: namespace),
+        query: make_query(
+          'propagationPolicy' => propagationPolicy,
+        ),
+        response_class: @resource_class, # XXX: documented as returning Status
+      )
+    end
+
+    # @param namespace [String]
+    # @param labelSelector [nil, String, Hash{String => String}]
+    # @param fieldSelector [nil, String, Hash{String => String}]
+    # @return [K8s::API::MetaV1::Status]
+    def delete_collection(namespace: @namespace, labelSelector: nil, fieldSelector: nil, propagationPolicy: nil)
+      list = @transport.request(
+        method: 'DELETE',
+        path: self.path(namespace: namespace),
+        query: make_query(
+          'labelSelector' => selector_query(labelSelector),
+          'fieldSelector' => selector_query(fieldSelector),
+          'propagationPolicy' => propagationPolicy,
+        ),
+        response_class: K8s::API::MetaV1::List, # XXX: documented as returning Status
+      )
+      process_list(list)
+    end
+
+    # @param resource [resource_class] with metadata
+    # @return [K8s::API::MetaV1::Status]
+    def delete_resource(resource, **options)
+      delete(resource.metadata.name, namespace: resource.metadata.namespace, **options)
+    end
+  end
+end