k8s-client 0.1.0

data/docker-compose.yaml

@@ -0,0 +1,10 @@
+rspec:
+  build: .
+  volumes:
+  - .:/app
+  entrypoint: bundle exec rspec
+k8s-client:
+  build: .
+  volumes:
+  - .:/app
+  entrypoint: bundle exec bin/k8s-client

data/k8s-client.gemspec

@@ -0,0 +1,35 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "k8s/client/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "k8s-client"
+  spec.version       = K8s::Client::VERSION
+  spec.authors       = ["Kontena, Inc."]
+  spec.email         = ["info@kontena.io"]
+  spec.license       = "Apache-2.0"
+
+  spec.summary       = "Kubernetes client library"
+  spec.homepage      = "https://github.com/kontena/k8s-client"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "bin"
+  spec.executables   = []
+  spec.require_paths = ["lib"]
+  spec.required_ruby_version = '~> 2.4'
+
+  spec.add_runtime_dependency "excon", "~> 0.62.0"
+  spec.add_runtime_dependency "dry-struct", "~> 0.5.0"
+  spec.add_runtime_dependency "deep_merge", "~> 1.2.1"
+  spec.add_runtime_dependency "recursive-open-struct", "~> 1.1.0"
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.7"
+  spec.add_development_dependency "webmock", "~> 3.4.2"
+end

data/lib/k8s-client.rb

@@ -0,0 +1,13 @@
+require 'k8s/api/metav1'
+require 'k8s/api/version'
+
+require 'k8s/config'
+require 'k8s/logging'
+
+require 'k8s/api_client'
+require "k8s/client"
+require "k8s/error"
+require 'k8s/resource'
+require 'k8s/resource_client'
+require 'k8s/stack'
+require 'k8s/transport'

data/lib/k8s/api.rb

@@ -0,0 +1,26 @@
+require 'dry-types'
+require 'dry-struct'
+
+module K8s
+  module API
+    module Types
+      include Dry::Types.module
+    end
+
+    class Struct < Dry::Struct
+      # input from JSON with string keys
+      transform_keys(&:to_sym)
+
+      # @param data [Hash]
+      # @return [self]
+      def self.from_json(data)
+        return new(data)
+      end
+
+      # @return [String]
+      def to_json
+        to_hash.to_json
+      end
+    end
+  end
+end

data/lib/k8s/api/metav1.rb

@@ -0,0 +1,20 @@
+require 'k8s/api'
+
+module K8s
+  module API
+    module MetaV1
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#TypeMeta
+      class Resource < Struct
+        # XXX: making these optional seems dangerous, but some APIs (GET /api/v1) are missing these
+        attribute :kind, Types::Strict::String.optional.default(nil)
+        attribute :apiVersion, Types::Strict::String.optional.default(nil)
+      end
+    end
+  end
+end
+
+require 'k8s/api/metav1/api_group'
+require 'k8s/api/metav1/api_resource'
+require 'k8s/api/metav1/list'
+require 'k8s/api/metav1/object'
+require 'k8s/api/metav1/status'

data/lib/k8s/api/metav1/api_group.rb

@@ -0,0 +1,22 @@
+module K8s
+  module API
+    module MetaV1
+      class APIGroupVersion < Struct
+        attribute :groupVersion, Types::Strict::String
+        attribute :version, Types::Strict::String
+      end
+
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#APIGroup
+      class APIGroup < Struct
+        attribute :name, Types::Strict::String
+        attribute :versions, Types::Strict::Array.of(APIGroupVersion)
+        attribute :preferredVersion, APIGroupVersion
+      end
+
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#APIGroupList
+      class APIGroupList < Resource
+        attribute :groups, Types::Strict::Array.of(APIGroup)
+      end
+    end
+  end
+end

data/lib/k8s/api/metav1/api_resource.rb

@@ -0,0 +1,24 @@
+module K8s
+  module API
+    module MetaV1
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#APIResource
+      class APIResource < Struct
+        attribute :name, Types::Strict::String
+        attribute :singularName, Types::Strict::String
+        attribute :namespaced, Types::Strict::Bool
+        attribute :group, Types::Strict::String.optional.default(nil)
+        attribute :version, Types::Strict::String.optional.default(nil)
+        attribute :kind, Types::Strict::String
+        attribute :verbs, Types::Strict::Array.of(Types::Strict::String)
+        attribute :shortNames, Types::Strict::Array.of(Types::Strict::String).optional.default([])
+        attribute :categories, Types::Strict::Array.of(Types::Strict::String).optional.default([])
+      end
+
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#APIResourceList
+      class APIResourceList < Resource
+        attribute :groupVersion, Types::Strict::String
+        attribute :resources, Types::Strict::Array.of(APIResource)
+      end
+    end
+  end
+end

data/lib/k8s/api/metav1/list.rb

@@ -0,0 +1,18 @@
+module K8s
+  module API
+    module MetaV1
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#ListMeta
+      class ListMeta < Struct
+        attribute :selfLink, Types::Strict::String.optional.default(nil)
+        attribute :resourceVersion, Types::Strict::String.optional.default(nil)
+        attribute :continue, Types::Strict::String.optional.default(nil)
+      end
+
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#List
+      class List < Resource
+        attribute :metadata, ListMeta
+        attribute :items, Types::Strict::Array # untyped
+      end
+    end
+  end
+end

data/lib/k8s/api/metav1/object.rb

@@ -0,0 +1,51 @@
+require 'k8s/api/metav1/status'
+
+module K8s
+  module API
+    module MetaV1
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#OwnerReference
+      class OwnerReference < Resource
+        attribute :name, Types::Strict::String
+        attribute :uid, Types::Strict::String
+        attribute :controller, Types::Strict::Bool.optional.default(nil)
+        attribute :blockOwnerDeletion, Types::Strict::Bool.optional.default(nil)
+      end
+
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#Initializer
+      class Initializer < Struct
+        attribute :name, Types::Strict::String
+      end
+
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#Initializers
+      class Initializers < Struct
+        attribute :pending, Initializer
+        attribute :result, Status.optional.default(nil)
+      end
+
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#ObjectMeta
+      class ObjectMeta < Resource
+        attribute :name, Types::Strict::String.optional.default(nil)
+        attribute :generateName, Types::Strict::String.optional.default(nil)
+        attribute :namespace, Types::Strict::String.optional.default(nil)
+        attribute :selfLink, Types::Strict::String.optional.default(nil)
+        attribute :uid, Types::Strict::String.optional.default(nil)
+        attribute :resourceVersion, Types::Strict::String.optional.default(nil)
+        attribute :generation, Types::Strict::Integer.optional.default(nil)
+        attribute :creationTimestamp, Types::DateTime.optional.default(nil)
+        attribute :deletionTimestamp, Types::DateTime.optional.default(nil)
+        attribute :deletionGracePeriodSeconds, Types::Strict::Integer.optional.default(nil)
+        attribute :labels, Types::Strict::Hash.map(Types::Strict::String, Types::Strict::String).optional.default(nil)
+        attribute :annotations, Types::Strict::Hash.map(Types::Strict::String, Types::Strict::String).optional.default(nil)
+        attribute :ownerReferences, Types::Strict::Array.of(OwnerReference).optional.default([])
+        attribute :initializers, Initializers.optional.default(nil)
+        attribute :finalizers, Types::Strict::Array.of(Types::Strict::String).optional.default([])
+        attribute :clusterName, Types::Strict::String.optional.default(nil)
+      end
+
+      # common attributes shared by all object types
+      class ObjectCommon < Resource
+        attribute :metadata, ObjectMeta.optional.default(nil)
+      end
+    end
+  end
+end

data/lib/k8s/api/metav1/status.rb

@@ -0,0 +1,31 @@
+module K8s
+  module API
+    module MetaV1
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#Status
+      class Status < Resource
+
+        class Cause < Struct
+          attribute :reason, Types::Strict::String.optional.default(nil)
+          attribute :message, Types::Strict::String.optional.default(nil) # human-readable
+          attribute :field, Types::Strict::String.optional.default(nil) # human-readable
+        end
+
+        class Details < Struct
+          attribute :name, Types::Strict::String.optional.default(nil)
+          attribute :group, Types::Strict::String.optional.default(nil)
+          attribute :kind, Types::Strict::String.optional.default(nil)
+          attribute :uid, Types::Strict::String.optional.default(nil)
+          attribute :causes, Types::Strict::Array.of(Cause).optional.default(nil)
+          attribute :retryAfterSeconds, Types::Strict::Integer.optional.default(nil)
+        end
+
+        attribute :metadata, ListMeta
+        attribute :status, Types::Strict::String.enum('Success', 'Failure').optional.default(nil)
+        attribute :message, Types::Strict::String.optional.default(nil) # human-readable
+        attribute :reason, Types::Strict::String.optional.default(nil) # machine-readable
+        attribute :details, Details.optional.default(nil)
+        attribute :code, Types::Strict::Integer.optional.default(nil)
+      end
+    end
+  end
+end

data/lib/k8s/api/version.rb

@@ -0,0 +1,14 @@
+module K8s
+  module API
+    class Version < Struct
+      attribute :buildDate, Types::Strict::String # TODO: parse datetime?
+      attribute :compiler, Types::Strict::String
+      attribute :gitCommit, Types::Strict::String
+      attribute :gitTreeState, Types::Strict::String
+      attribute :gitVersion, Types::Strict::String
+      attribute :major, Types::Strict::String
+      attribute :minor, Types::Strict::String
+      attribute :platform, Types::Strict::String
+    end
+  end
+end

data/lib/k8s/api_client.rb

@@ -0,0 +1,109 @@
+module K8s
+  class APIClient
+    def self.path(api_version)
+      if api_version.include? '/'
+        File.join('/apis', api_version)
+      else
+        File.join('/api', api_version)
+      end
+
+    end
+
+    # @param transport [K8s::Transport]
+    # @param api_version [String] "group/version" or "version" (core)
+    def initialize(transport, api_version)
+      @transport = transport
+      @api_version = api_version
+    end
+
+    # @return [String]
+    def api_version
+      @api_version
+    end
+
+    def path(*path)
+      @transport.path(self.class.path(@api_version), *path)
+    end
+
+    # @return [Bool] loaded yet?
+    def api_resources?
+      !!@api_resources
+    end
+
+    # @param api_resources [Array<K8s::API::MetaV1::APIResource>]
+    def api_resources=(api_resources)
+      @api_resources = api_resources
+    end
+
+    # Force-update APIResources
+    #
+    # @return [Array<K8s::API::MetaV1::APIResource>]
+    def api_resources!
+      @api_resources = @transport.get(self.path,
+        response_class: K8s::API::MetaV1::APIResourceList,
+      ).resources
+    end
+
+    # Cached APIResources
+    #
+    # @return [Array<K8s::API::MetaV1::APIResource>]
+    def api_resources
+      @api_resources || api_resources!
+    end
+
+    # @param resource_name [String]
+    # @param namespace [String, nil]
+    # @raise [K8s::Error] unknown resource
+    # @return [K8s::ResourceClient]
+    def resource(resource_name, namespace: nil)
+      unless api_resource = api_resources.find{ |api_resource| api_resource.name == resource_name }
+        raise K8s::Error, "Unknown resource #{resource_name} for #{@api_version}"
+      end
+
+      ResourceClient.new(@transport, self, api_resource,
+        namespace: namespace,
+      )
+    end
+
+    # @param resource [K8s::Resource]
+    # @param namespace [String, nil] default if resource is missing namespace
+    # @raise [K8s::Error] unknown resource
+    # @return [K8s::ResourceClient]
+    def client_for_resource(resource, namespace: nil)
+      unless @api_version == resource.apiVersion
+        raise K8s::Error, "Invalid apiVersion=#{resource.apiVersion} for #{@api_version} client"
+      end
+
+      unless api_resource = api_resources.find{ |api_resource| api_resource.kind == resource.kind }
+        raise K8s::Error, "Unknown resource kind=#{api_resource.kind} for #{@api_version}"
+      end
+
+      ResourceClient.new(@transport, self, api_resource,
+        namespace: resource.metadata.namespace || namespace,
+      )
+    end
+
+    # TODO: skip non-namespaced resources if namespace is given, or ignore namespace?
+    #
+    # @param namespace [String, nil]
+    # @return [Array<K8s::ResourceClient>]
+    def resources(namespace: nil)
+      api_resources.map{ |api_resource| ResourceClient.new(@transport, self, api_resource,
+        namespace: namespace,
+      ) }
+    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)
+      resources ||= self.resources.select{|resource| resource.list? }
+
+      ResourceClient.list(resource, @transport, **options)
+    end
+  end
+end

data/lib/k8s/client.rb

@@ -0,0 +1,148 @@
+require 'openssl'
+require 'base64'
+
+module K8s
+  # @return [K8s::Client]
+  def self.client(server, **options)
+    Client.new(Transport.new(server, **options))
+  end
+
+  class Client
+    # @param config [Phraos::Kube::Config]
+    # @return [K8s::Client]
+    def self.config(config)
+      new(Transport.config(config))
+    end
+
+    # @return [K8s::Client]
+    def self.in_cluster_config
+      new(Transport.in_cluster_config)
+    end
+
+    # @param transport [K8s::Transport]
+    def initialize(transport, namespace: nil)
+      @transport = transport
+      @namespace = namespace
+
+      @api_clients = {}
+    end
+
+    # @raise [K8s::Error]
+    # @return [K8s::API::Version]
+    def version
+      @transport.get('/version',
+        response_class: K8s::API::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!
+      @api_groups = @transport.get('/apis',
+        response_class: K8s::API::MetaV1::APIGroupList,
+      ).groups.map{|api_group| api_group.preferredVersion.groupVersion }
+    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
+    # @return [Array<APIClient>]
+    def apis(api_versions = nil, prefetch_resources: false)
+      api_versions ||= ['v1'] + self.api_groups
+
+      if prefetch_resources
+        # api groups that are missing their api_resources
+        api_paths = api_versions
+          .select{|api_version| !api(api_version).api_resources? }
+          .map{|api_version| APIClient.path(api_version) }
+
+        # load into APIClient.api_resources=
+        @transport.gets(*api_paths, response_class: K8s::API::MetaV1::APIResourceList).each do |api_resource_list|
+          api(api_resource_list.groupVersion).api_resources = api_resource_list.resources
+        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| api.resources(namespace: namespace) }.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)
+      resources ||= self.resources.select{|resource| resource.list? }
+
+      ResourceClient.list(resources, @transport, **options)
+    end
+
+    # @param resource [K8s::Resource]
+    # @param namespace [String, nil] default if resource is missing namespace
+    # @raise [K8s::Error] unknown resource
+    # @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
+
+    # @param resources [Array<K8s::Resource>]
+    # @return [Array<K8s::Resource, nil>]
+    def get_resources(resources)
+      # prefetch api resources
+      apis(resources.map{|resource| resource.apiVersion }.uniq, prefetch_resources: true)
+
+      resource_clients = resources.map{|resource| client_for_resource(resource) }
+      requests = resources.zip(resource_clients).map{|resource, resource_client|
+        {
+          method: 'GET',
+          path: resource_client.path(resource.metadata.name, namespace: resource.metadata.namespace),
+          response_class: resource_client.resource_class,
+        }
+      }
+      responses = @transport.requests(*requests, 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]
+    # @return [K8s::Resource]
+    def delete_resource(resource)
+      client_for_resource(resource).delete_resource(resource)
+    end
+  end
+end