k8s-ruby2 0.10.6

data/README.md

@@ -0,0 +1,227 @@
+# K8s::Client provided by k8s-ruby
+
+Ruby client library for the Kubernetes (1.9+) API.
+
+The `k8s-ruby` project is a fork of
+[kontena/k8s-client](https://github.com/kontena/k8s-client).
+
+Unfortunately the company
+[Kontena.io went bankcrupt](https://blog.kontena.io/farewell/) at
+the end of the year 2019. They had created many wonderful Ruby projects which we
+are grateful.
+
+The `k8s-ruby` library is a community effort to keep `k8s-client`
+maintained without any dependencies to the former Kontena.io organization.
+The library was renamed in order to publish it to Rubygems without conflicting
+with `k8s-client`.
+
+## Highlights
+
+* Clean API for dynamic Kubernetes API Groups / Resources
+* Fast API requests using HTTP connection keepalive
+* Fast API discovery and resource listings using pipelined HTTP requests
+* Typed errors with useful debugging information
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'k8s-ruby'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install k8s-ruby
+
+And then load the code using:
+
+```ruby
+require 'k8s-ruby'
+```
+
+## Usage
+
+### Overview
+The top-level `K8s::Client` provides access to separate `APIClient` instances for each Kubernetes API Group (`v1`, `apps/v1`, etc.), which in turns provides access to separate `ResourceClient` instances for each API resource type (`nodes`, `pods`, `deployments`, etc.).
+
+Individual resources are returned as `K8s::Resource` instances, which are `RecursiveOpenStruct` instances providing attribute access (`resource.metadata.name`). The resource instances are returned by methods such as `client.api('v1').resource('nodes').get('foo')`, and passed as arguments for `client.api('v1').resource('nodes').create_resource(res)`. Resources can also be loaded from disk using `K8s::Resource.from_files(path)`, and passed to the top-level methods such as `client.create_resource(res)`, which lookup the correct API/Resource client from the resource `apiVersion` and `kind`.
+
+The different `K8s::Error::API` subclasses represent different HTTP response codes, such as `K8s::Error::NotFound` or `K8s::Error::Conflict`.
+
+### Creating a client
+
+#### Unauthenticated client
+
+```ruby
+client = K8s.client('https://localhost:6443', ssl_verify_peer: false)
+```
+
+The keyword options are [Excon](https://github.com/excon/excon/) options.
+
+#### Client from kubeconfig
+
+```ruby
+client = K8s::Client.config(
+  K8s::Config.load_file(
+    File.expand_path '~/.kube/config'
+  )
+)
+```
+
+#### Supported kubeconfig options
+
+Not all kubeconfig options are supported, only the following kubeconfig options work:
+
+* `current-context`
+* `context.cluster`
+* `context.user`
+* `cluster.server`
+* `cluster.insecure_skip_tls_verify`
+* `cluster.certificate_authority`
+* `cluster.certificate_authority_data`
+* `user.client_certificate` + `user.client_key`
+* `user.client_certificate_data` + `user.client_key_data`
+* `user.token`
+
+##### With overrides
+
+```ruby
+client = K8s::Client.config(K8s::Config.load_file('~/.kube/config'),
+  server: 'http://localhost:8001',
+)
+```
+
+#### In-cluster client from pod envs/secrets
+
+```ruby
+client = K8s::Client.in_cluster_config
+```
+
+### Logging
+
+#### Quiet
+
+To supress any warning messages:
+
+```ruby
+K8s::Logging.quiet!
+K8s::Transport.quiet!
+```
+
+The `K8s::Transport` is quiet by default, but other components may log warnings in the future.
+
+#### Debugging
+
+Log all API requests
+
+```ruby
+K8s::Logging.debug!
+K8s::Transport.verbose!
+```
+
+```
+I, [2018-08-09T14:19:50.404739 #1]  INFO -- K8s::Transport: Using config with server=https://167.99.39.233:6443
+I, [2018-08-09T14:19:50.629521 #1]  INFO -- K8s::Transport<https://167.99.39.233:6443>: GET /version => HTTP 200: <K8s::API::Version> in 0.224s
+I, [2018-08-09T14:19:50.681367 #1]  INFO -- K8s::Transport<https://167.99.39.233:6443>: GET /api/v1 => HTTP 200: <K8s::API::MetaV1::APIResourceList> in 0.046s
+I, [2018-08-09T14:19:51.018740 #1]  INFO -- K8s::Transport<https://167.99.39.233:6443>: GET /api/v1/pods => HTTP 200: <K8s::API::MetaV1::List> in 0.316s
+```
+
+Using `K8s::Transport.debug!` will also log request/response bodies. The `EXCON_DEBUG=true` env will log all request/response attributes, including headers.
+
+### Prefetching API resources
+
+Operations like mapping a resource `kind` to an API resource URL require knowledge of the API resource lists for the API group. Mapping resources for multiple API groups would require fetching the API resource lists for each API group in turn, leading to additional request latency. This can be optimized using resource prefetching:
+
+```ruby
+client.apis(prefetch_resources: true)
+```
+
+This will fetch the API resource lists for all API groups in a single pipelined request.
+
+### Listing resources
+
+```ruby
+client.api('v1').resource('pods', namespace: 'default').list(labelSelector: {'role' => 'test'}).each do |pod|
+  puts "namespace=#{pod.metadata.namespace} pod: #{pod.metadata.name} node=#{pod.spec.nodeName}"
+end
+```
+
+### Updating resources
+
+```ruby
+node = client.api('v1').resource('nodes').get('test-node')
+
+node[:spec][:unschedulable] = true
+
+client.api('v1').resource('nodes').update_resource(node)
+```
+
+### Deleting resources
+
+```ruby
+pod = client.api('v1').resource('pods', namespace: 'default').delete('test-pod')
+```
+
+```ruby
+pods = client.api('v1').resource('pods', namespace: 'default').delete_collection(labelSelector: {'role' => 'test'})
+```
+
+### Creating resources
+
+#### Programmatically defined resources
+```ruby
+service = K8s::Resource.new(
+  apiVersion: 'v1',
+  kind: 'Service',
+  metadata: {
+    namespace: 'default',
+    name: 'test',
+  },
+  spec: {
+    type: 'ClusterIP',
+    ports: [
+      { port: 80 },
+    ],
+    selector: {'app' => 'test'},
+  },
+)
+
+logger.info "Create service=#{service.metadata.name} in namespace=#{service.metadata.namespace}"
+
+service = client.api('v1').resource('services').create_resource(service)
+```
+
+#### From file(s)
+
+```ruby
+resources = K8s::Resource.from_files('./test.yaml')
+
+for resource in resources
+  resource = client.create_resource(resource)
+end
+```
+
+### Patching resources
+
+```ruby
+client.api('apps/v1').resource('deployments', namespace: 'default').merge_patch('test', {
+    spec: { replicas: 3 },
+})
+```
+
+### Watching resources
+
+```ruby
+client.api('v1').resource('pods', namespace: 'default').watch(labelSelector: {'role' => 'test'}) do |watch_event|
+  puts "type=#{watch_event.type} pod=#{watch_event.resource.metadata.name}"
+end
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [k8s-ruby/k8s-ruby](https://github.com/k8s-ruby/k8s-ruby).

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+RuboCop::RakeTask.new(:rubocop).tap do |task|
+  task.options = %w(--fail-level A -S --format c)
+  if RUBY_ENGINE == 'ruby' && RbConfig::CONFIG['host_os'] !~ /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+    task.options << '--parallel'
+  end
+end
+
+task default: [:spec, :rubocop]

data/docker-compose.yaml

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

data/k8s-ruby2.gemspec

@@ -0,0 +1,40 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "k8s/ruby/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "k8s-ruby2"
+  spec.version       = K8s::Ruby::VERSION
+  spec.authors       = ["rdx.net", "Kontena, Inc."]
+  spec.email         = ["firstname.lastname@rdx.net"]
+  spec.license       = "Apache-2.0"
+
+  spec.summary       = "Kubernetes client library for Ruby"
+  spec.homepage      = "https://github.com/tsutsu/k8s-ruby"
+
+  # 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(__dir__)) 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 "dry-struct", "~> 1.4.0"
+  spec.add_runtime_dependency "dry-types", "~> 1.5.0"
+  spec.add_runtime_dependency "excon", "~> 0.78"
+  spec.add_runtime_dependency "recursive-open-struct", "~> 1.1.3"
+  spec.add_runtime_dependency "yaml-safe_load_stream2", "~> 0.1.1"
+  spec.add_runtime_dependency 'hashdiff', '~> 1.0.1'
+  spec.add_runtime_dependency 'jsonpath', '~> 1.1.0'
+  spec.add_runtime_dependency 'yajl-ruby', '~> 1.4.1'
+
+  spec.add_development_dependency "bundler", ">= 1.17", "< 3.0"
+  spec.add_development_dependency "rake", ">= 12.3.3"
+  spec.add_development_dependency "rspec", "~> 3.10"
+  spec.add_development_dependency "webmock", "~> 3.11.0"
+  spec.add_development_dependency "rubocop", "~> 1.8.0"
+  spec.add_development_dependency "byebug", "~> 11.1.3"
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module K8s
+  module API
+    module MetaV1
+      # structured list of available APIGroup versions
+      # groupVersion provided for convenience
+      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,26 @@
+# frozen_string_literal: true
+
+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, shared: true)
+        attribute :version, Types::Strict::String.optional.default(nil, shared: true)
+        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(proc { [] }, shared: true)
+        attribute :categories, Types::Strict::Array.of(Types::Strict::String).optional.default(proc { [] }, shared: true)
+      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,20 @@
+# frozen_string_literal: true
+
+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,53 @@
+# frozen_string_literal: true
+
+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, shared: true)
+        attribute :blockOwnerDeletion, Types::Strict::Bool.optional.default(nil, shared: true)
+      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, shared: true)
+      end
+
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#ObjectMeta
+      class ObjectMeta < Resource
+        attribute :name, Types::Strict::String.optional.default(nil, shared: true)
+        attribute :generateName, Types::Strict::String.optional.default(nil, shared: true)
+        attribute :namespace, Types::Strict::String.optional.default(nil, shared: true)
+        attribute :selfLink, Types::Strict::String.optional.default(nil, shared: true)
+        attribute :uid, Types::Strict::String.optional.default(nil, shared: true)
+        attribute :resourceVersion, Types::Strict::String.optional.default(nil, shared: true)
+        attribute :generation, Types::Strict::Integer.optional.default(nil, shared: true)
+        attribute :creationTimestamp, Types::DateTime.optional.default(nil, shared: true)
+        attribute :deletionTimestamp, Types::DateTime.optional.default(nil, shared: true)
+        attribute :deletionGracePeriodSeconds, Types::Strict::Integer.optional.default(nil, shared: true)
+        attribute :labels, Types::Strict::Hash.map(Types::Strict::String, Types::Strict::String).optional.default(nil, shared: true)
+        attribute :annotations, Types::Strict::Hash.map(Types::Strict::String, Types::Strict::String).optional.default(nil, shared: true)
+        attribute :ownerReferences, Types::Strict::Array.of(OwnerReference).optional.default([].freeze)
+        attribute :initializers, Initializers.optional.default(nil, shared: true)
+        attribute :finalizers, Types::Strict::Array.of(Types::Strict::String).optional.default([].freeze)
+        attribute :clusterName, Types::Strict::String.optional.default(nil, shared: true)
+      end
+
+      # common attributes shared by all object types
+      class ObjectCommon < Resource
+        attribute :metadata, ObjectMeta.optional.default(nil, shared: true)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module K8s
+  module API
+    module MetaV1
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#Status
+      class Status < Resource
+        # structured cause
+        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
+
+        # structured details
+        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/metav1/watch_event.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../../resource'
+
+module K8s
+  module API
+    module MetaV1
+      # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1#WatchEvent
+      class WatchEvent < Resource
+        attribute :type, Types::Strict::String
+        attribute :object, Types::Strict::Hash
+
+        # @return [K8s::Resource]
+        def resource
+          @resource ||= K8s::Resource.new(object)
+        end
+      end
+    end
+  end
+end

data/lib/k8s/api/metav1.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'k8s/api'
+
+module K8s
+  module API
+    # API types common to all apigroups/versions
+    #
+    # @see https://godoc.org/k8s.io/apimachinery/pkg/apis/meta/v1
+    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'
+require 'k8s/api/metav1/watch_event'

data/lib/k8s/api/version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module K8s
+  module API
+    # GET /version
+    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.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'dry-types'
+require 'dry-struct'
+
+module K8s
+  # Kube API definitions
+  module API
+    # Common Dry::Types used in the API
+    module Types
+      include Dry::Types()
+    end
+
+    # Common API struct type, handling JSON transforms with symbol keys
+    class Struct < Dry::Struct
+      # input from JSON with string keys
+      transform_keys(&:to_sym)
+
+      # @param data [Hash]
+      # @return [self]
+      def self.from_json(data)
+        new(Yajl::Parser.parse(data))
+      end
+
+      # @return [String]
+      def to_json(*_args)
+        to_hash.to_json
+      end
+    end
+  end
+end

data/lib/k8s/api_client.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module K8s
+  # Per-APIGroup/version client.
+  #
+  # Offers access to {ResourceClient} instances for the APIResource types defined in this apigroup/version
+  class APIClient
+    # @param api_version [String] either core version (v1) or apigroup/apiversion (apps/v1)
+    # @return [String]
+    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]
+    attr_reader :api_version
+
+    # @param path [Array<String>] join path from parts
+    # @return [String]
+    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>]
+    attr_writer :api_resources
+
+    # Force-update APIResources
+    #
+    # @return [Array<K8s::API::MetaV1::APIResource>]
+    def api_resources!
+      @api_resources = @transport.get(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]
+    # @raise [K8s::Error::UndefinedResource]
+    # @return [K8s::API::MetaV1::APIResource]
+    def find_api_resource(resource_name)
+      found_resource = api_resources.find{ |api_resource| api_resource.name == resource_name }
+      found_resource ||= api_resources!.find{ |api_resource| api_resource.name == resource_name }
+      raise K8s::Error::UndefinedResource, "Unknown resource #{resource_name} for #{@api_version}" unless found_resource
+
+      found_resource
+    end
+
+    # @param resource_name [String]
+    # @param namespace [String, nil]
+    # @raise [K8s::Error::UndefinedResource]
+    # @return [K8s::ResourceClient]
+    def resource(resource_name, namespace: nil)
+      ResourceClient.new(@transport, self, find_api_resource(resource_name), namespace: namespace)
+    end
+
+    # @param resource [K8s::Resource]
+    # @param namespace [String, nil] default if resource is missing namespace
+    # @raise [K8s::Error::UndefinedResource]
+    # @return [K8s::ResourceClient]
+    def client_for_resource(resource, namespace: nil)
+      unless @api_version == resource.apiVersion
+        raise K8s::Error::UndefinedResource, "Invalid apiVersion=#{resource.apiVersion} for #{@api_version} client"
+      end
+
+      found_resource = api_resources.find{ |api_resource| api_resource.kind == resource.kind }
+      found_resource ||= api_resources!.find{ |api_resource| api_resource.kind == resource.kind }
+      raise K8s::Error::UndefinedResource, "Unknown resource kind=#{resource.kind} for #{@api_version}" unless found_resource
+
+      ResourceClient.new(@transport, self, found_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(&:list?)
+
+      ResourceClient.list(resources, @transport, **options)
+    end
+  end
+end