k8s-ruby 0.10.5

data/README.md

@@ -0,0 +1,214 @@
+# K8s::Client provided by k8s-ruby
+
+Ruby client library for the Kubernetes (1.9+) API
+
+## 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 [rdxnet/k8s-ruby](https://github.com/rdxnet/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/bin/k8s-client

@@ -0,0 +1,337 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'optparse'
+require 'uri'
+require 'k8s-ruby'
+
+Options = Struct.new(
+  :in_cluster_config,
+  :config,
+  :server,
+  :insecure_skip_tls_verify,
+  :prefetch_resources,
+  :list_resource_kinds,
+  :namespace,
+  :all_namespaces,
+  :label_selector,
+  :pipeline_list,
+  :list_resources,
+  :list_pods,
+  :update_node,
+  :node_unschedulable,
+  :delete_pod,
+  :delete_pods,
+  :create_service,
+  :service_type,
+  :service_port,
+  :resources,
+  :create_resources,
+  :update_resources,
+  :delete_resources,
+  :stack_name,
+  :stack,
+  :prune_stack,
+  :delete_stack,
+  :api,
+  :list_api_resources,
+  :patch_deployment,
+  :replicas,
+  :version
+)
+
+options = Options.new
+options.create_resources = []
+options.update_resources = []
+options.delete_resources = []
+
+logger = Logger.new(STDERR)
+
+opt_parser = OptionParser.new do |parser|
+  parser.on('--debug-api') do
+    K8s::Logging.debug!
+    K8s::Transport.debug!
+  end
+  parser.on('--debug') do
+    K8s::Logging.debug!
+    K8s::Transport.verbose!
+  end
+  parser.on('--verbose') do
+    K8s::Logging.verbose!
+    K8s::Transport.quiet!
+  end
+  parser.on('--quiet') do
+    K8s::Logging.quiet!
+    K8s::Transport.quiet!
+  end
+  parser.on('--version') do
+    options.version = true
+  end
+  parser.on('--in-cluster-config') do
+    options.in_cluster_config = true
+  end
+  parser.on('--kubeconfig=PATH') do |path|
+    options.config = K8s::Config.load_file(path)
+  end
+  parser.on('--server=SERVER') do |server|
+    options.server = server
+  end
+  parser.on('--insecure-skip-tls-verify', TrueClass) do |bool|
+    options.insecure_skip_tls_verify = bool
+  end
+  parser.on('--prefetch-resources', TrueClass) do |bool|
+    options.prefetch_resources = bool
+  end
+  parser.on('--list-resource-kinds', TrueClass) do |_bool|
+    options.list_resource_kinds = true
+  end
+  parser.on('-n', '--namespace=NAMESPACE') do |namespace|
+    options.namespace = namespace
+  end
+  parser.on('--all-namespaces') do
+    options.all_namespaces = true
+  end
+  parser.on('-l', '--label-selector=LABEL=VALUE') do |selector|
+    options.label_selector = selector
+  end
+  parser.on('--pipeline-list') do
+    options.pipeline_list = true
+  end
+  parser.on('--list-resources') do
+    options.list_resources = true
+  end
+  parser.on('--list-pods') do
+    options.list_pods = true
+  end
+  parser.on('--update-node=NODE') do |node|
+    options.update_node = node
+  end
+  parser.on('--node-unschedulable=BOOL', TrueClass) do |bool|
+    options.node_unschedulable = bool
+  end
+  parser.on('--delete-pod=POD') do |pod|
+    options.delete_pod = pod
+  end
+  parser.on('--delete-pods') do
+    options.delete_pods = true
+  end
+  parser.on('--create-service=SERVICE') do |service|
+    options.create_service = service
+  end
+  parser.on('--service-type=SERVICE-TYPE') do |type|
+    options.service_type = type
+  end
+  parser.on('--service-port=PORT', Integer) do |port|
+    options.service_port = port
+  end
+  parser.on('--resource-file=path') do |path|
+    options.resources = K8s::Resource.from_files(path)
+  end
+  parser.on('--create') do
+    options.create_resources = options.resources
+  end
+  parser.on('--update') do
+    options.update_resources = options.resources
+  end
+  parser.on('--delete') do
+    options.delete_resources = options.resources
+  end
+  parser.on('--stack-name=NAME') do |name|
+    options.stack_name = name
+  end
+  parser.on('--stack=PATH') do |path|
+    options.stack = K8s::Stack.load(options.stack_name || File.basename(path, ".*"), path)
+  end
+  parser.on('--prune-stack', TrueClass) do |flag|
+    options.prune_stack = flag
+  end
+  parser.on('--delete-stack') do
+    options.delete_stack = options.stack
+  end
+  parser.on('--api=API') do |api|
+    options.api = api
+  end
+  parser.on('--list-api-resources') do
+    options.list_api_resources = options.api
+  end
+  parser.on('--patch-deployment=NAME') do |name|
+    options.patch_deployment = name
+  end
+  parser.on('--replicas=COUNT', Integer) do |count|
+    options.replicas = count
+  end
+end
+
+opt_parser.parse!
+
+if options.config
+  overrides = {}
+  overrides[:ssl_verify_peer] = false if options.insecure_skip_tls_verify
+
+  client = K8s::Client.config(options.config,
+                              server: options.server,
+                              **overrides)
+elsif options.in_cluster_config
+  client = K8s::Client.in_cluster_config
+else
+  client = K8s.client(options.server,
+                      ssl_verify_peer: !options.insecure_skip_tls_verify)
+end
+
+if options.version
+  logger.info client.version
+else
+  logger.info "Kube server version: #{client.version.gitVersion}"
+end
+
+if options.prefetch_resources
+  client.apis(prefetch_resources: true)
+end
+
+if options.list_resource_kinds
+  client.resources.sort_by(&:kind).each do |resource_client|
+    next if resource_client.subresource?
+
+    puts "#{resource_client.kind} => #{resource_client.api_version} #{resource_client.name}"
+  end
+end
+
+namespace = if options.all_namespaces
+              nil # all
+            elsif options.namespace
+              options.namespace
+            elsif options.config && ns = options.config.context.namespace
+              ns
+            end
+
+if options.list_api_resources
+  logger.info "List resource types for api=#{options.list_api_resources}..."
+
+  client.api(options.list_api_resources).resources do |api_resource|
+    logger.info "api=#{api_resource.api_version} resource=#{api_resource.resource} subresource=#{api_resource.subresource}"
+  end
+end
+
+if options.pipeline_list
+  objects = client.list_resources(namespace: namespace, labelSelector: options.label_selector)
+  objects.each do |object|
+    logger.info "api=#{object.apiVersion} kind=#{object.kind} namespace=#{object.metadata.namespace} name=#{object.metadata.name}"
+  end
+elsif options.list_resources
+  client.apis(prefetch_resources: true).each do |api|
+    logger.info "api=#{api.api_version}"
+
+    resources = api.resources.select(&:list?)
+
+    resources.each do |resource|
+      logger.info "api=#{api.api_version} resource=#{resource.name}"
+
+      objects = resource.list(labelSelector: options.label_selector)
+      objects.each do |object|
+        logger.info "api=#{object.apiVersion} kind=#{object.kind} namespace=#{object.metadata.namespace} name=#{object.metadata.name}"
+      end
+    end
+  end
+end
+
+if options.list_pods
+  client.api('v1').resource('pods', namespace: namespace).list(labelSelector: options.label_selector).each do |pod|
+    puts "namespace=#{pod.metadata.namespace} pod: #{pod.metadata.name} node=#{pod.spec.nodeName}"
+  end
+end
+
+if options.update_node
+  node = client.api('v1').resource('nodes').get(options.update_node)
+
+  puts "Update node=#{node.metadata.name}..."
+
+  if !options.node_unschedulable.nil?
+    puts "Set node=#{node.metadata.name} unschedulable: #{node.spec.unschedulable} => #{options.node_unschedulable}"
+
+    node[:spec][:unschedulable] = options.node_unschedulable
+  end
+
+  client.api('v1').resource('nodes').update_resource(node)
+end
+
+if options.delete_pod
+  logger.info "Delete pod=#{options.delete_pod} in namespace=#{namespace}"
+
+  pod = client.api('v1').resource('pods', namespace: namespace).delete(options.delete_pod)
+
+  logger.debug { pod.metadata }
+end
+
+if options.delete_pods
+  logger.info "Delete pods with labelSelector=#{options.label_selector} in namespace=#{namespace}"
+
+  pods = client.api('v1').resource('pods', namespace: namespace).delete_collection(labelSelector: options.label_selector)
+
+  pods.each do |pod_instance|
+    logger.info "Deleted pod=#{pod_instance.metadata.name} in namespace=#{pod_instance.metadata.namespace} on node=#{pod_instance.spec.nodeName}"
+  end
+end
+
+if options.create_service
+  service = K8s::Resource.new(
+    apiVersion: 'v1',
+    kind: 'Service',
+    metadata: {
+      namespace: namespace,
+      name: options.create_service
+    },
+    spec: {
+      type: options.service_type,
+      ports: [
+        { port: options.service_port }
+      ],
+      selector: Hash[options.label_selector.split('=', 2)]
+    }
+  )
+
+  logger.info "Create service=#{service.metadata.name} in namespace=#{service.metadata.namespace}"
+
+  service = client.api('v1').resource('services').create_resource(service)
+
+  logger.debug { service }
+end
+
+options.create_resources.each do |resource|
+  resource = client.create_resource(resource)
+
+  logger.info "Created #{resource.apiVersion} resource #{resource.kind} #{resource.metadata.name} in namespace #{resource.metadata.namespace}:\n#{JSON.pretty_generate(resource)}"
+end
+
+options.update_resources.each do |resource|
+  resource = client.update_resource(resource)
+
+  logger.info "Updated #{resource.apiVersion} resource #{resource.kind} #{resource.metadata.name} in namespace #{resource.metadata.namespace}:\n#{JSON.pretty_generate(resource)}"
+end
+
+options.delete_resources.each do |resource|
+  begin
+    resource = client.delete_resource(resource)
+
+    logger.info "Deleted #{resource.apiVersion} resource #{resource.kind} #{resource.metadata.name} in namespace #{resource.metadata.namespace}:\n#{JSON.pretty_generate(resource)}"
+  rescue K8s::Error::NotFound => e
+    logger.info "Skip #{resource.apiVersion} resource #{resource.kind} #{resource.metadata.name} in namespace #{resource.metadata.namespace}: #{e}"
+  end
+end
+
+if stack = options.delete_stack
+  logger.info "Delete stack #{stack.name}..."
+
+  stack.delete(client)
+
+elsif options.stack
+  logger.info "Apply stack #{options.stack.name}..."
+
+  options.stack.apply(client, prune: options.prune_stack)
+end
+
+if name = options.patch_deployment
+  client.api('apps/v1').resource('deployments', namespace: namespace).merge_patch(
+    name,
+    spec: { replicas: options.replicas }
+  )
+end