kubeclient 2.5.2 → 3.0.0

data/lib/kubeclient/config.rb

@@ -20,7 +20,7 @@ module Kubeclient
     def initialize(kcfg, kcfg_path)
       @kcfg = kcfg
       @kcfg_path = kcfg_path
-      fail 'Unknown kubeconfig version' if @kcfg['apiVersion'] != 'v1'
+      raise 'Unknown kubeconfig version' if @kcfg['apiVersion'] != 'v1'
     end
 
     def self.read(filename)
@@ -72,13 +72,13 @@ module Kubeclient
         break x['context'] if x['name'] == context_name
       end
 
-      fail "Unknown context #{context_name}" unless context
+      raise KeyError, "Unknown context #{context_name}" unless context
 
       cluster = @kcfg['clusters'].detect do |x|
         break x['cluster'] if x['name'] == context['cluster']
       end
 
-      fail "Unknown cluster #{context['cluster']}" unless cluster
+      raise KeyError, "Unknown cluster #{context['cluster']}" unless cluster
 
       user = @kcfg['users'].detect do |x|
         break x['user'] if x['name'] == context['user']
@@ -89,25 +89,25 @@ module Kubeclient
 
     def fetch_cluster_ca_data(cluster)
       if cluster.key?('certificate-authority')
-        return File.read(ext_file_path(cluster['certificate-authority']))
+        File.read(ext_file_path(cluster['certificate-authority']))
       elsif cluster.key?('certificate-authority-data')
-        return Base64.decode64(cluster['certificate-authority-data'])
+        Base64.decode64(cluster['certificate-authority-data'])
       end
     end
 
     def fetch_user_cert_data(user)
       if user.key?('client-certificate')
-        return File.read(ext_file_path(user['client-certificate']))
+        File.read(ext_file_path(user['client-certificate']))
       elsif user.key?('client-certificate-data')
-        return Base64.decode64(user['client-certificate-data'])
+        Base64.decode64(user['client-certificate-data'])
       end
     end
 
     def fetch_user_key_data(user)
       if user.key?('client-key')
-        return File.read(ext_file_path(user['client-key']))
+        File.read(ext_file_path(user['client-key']))
       elsif user.key?('client-key-data')
-        return Base64.decode64(user['client-key-data'])
+        Base64.decode64(user['client-key-data'])
       end
     end
 
@@ -116,7 +116,7 @@ module Kubeclient
       if user.key?('token')
         options[:bearer_token] = user['token']
       else
-        %w(username password).each do |attr|
+        %w[username password].each do |attr|
           options[attr.to_sym] = user[attr] if user.key?(attr)
         end
       end

data/lib/kubeclient/http_error.rb

@@ -0,0 +1,25 @@
+# TODO: remove this on next major version bump
+# Deprected http exception
+class KubeException < StandardError
+  attr_reader :error_code, :message, :response
+
+  def initialize(error_code, message, response)
+    @error_code = error_code
+    @message = message
+    @response = response
+  end
+
+  def to_s
+    string = "HTTP status code #{@error_code}, #{@message}"
+    if @response.is_a?(RestClient::Response) && @response.request
+      string << " for #{@response.request.method.upcase} #{@response.request.url}"
+    end
+    string
+  end
+end
+
+module Kubeclient
+  # Exception that is raised when a http request fails
+  class HttpError < KubeException
+  end
+end

data/lib/kubeclient/missing_kind_compatibility.rb

@@ -58,7 +58,7 @@ module Kubeclient
         'templates'                  => 'Template',
         'useridentitymappings'       => 'UserIdentityMapping',
         'users'                      => 'User'
-      }
+      }.freeze
 
       def self.resource_kind(name)
         MAPPING[name]

data/lib/kubeclient/resource.rb

@@ -0,0 +1,11 @@
+require 'recursive_open_struct'
+
+module Kubeclient
+  # Represents all the objects returned by Kubeclient
+  class Resource < RecursiveOpenStruct
+    def initialize(hash = nil, args = {})
+      args[:recurse_over_arrays] = true
+      super(hash, args)
+    end
+  end
+end

data/lib/kubeclient/resource_not_found_error.rb

@@ -0,0 +1,4 @@
+module Kubeclient
+  class ResourceNotFoundError < HttpError
+  end
+end

data/lib/kubeclient/version.rb

@@ -1,4 +1,4 @@
 # Kubernetes REST-API Client
 module Kubeclient
-  VERSION = '2.5.2'
+  VERSION = '3.0.0'.freeze
 end

data/lib/kubeclient/watch_stream.rb

@@ -4,11 +4,11 @@ module Kubeclient
   module Common
     # HTTP Stream used to watch changes on entities
     class WatchStream
-      def initialize(uri, http_options, format: :json)
+      def initialize(uri, http_options, as:)
         @uri = uri
         @http_client = nil
         @http_options = http_options
-        @format = format
+        @as = as
       end
 
       def each
@@ -17,14 +17,20 @@ module Kubeclient
         @http_client = build_client
         response = @http_client.request(:get, @uri, build_client_options)
         unless response.code < 300
-          fail KubeException.new(response.code, response.reason, response)
+          raise Kubeclient::HttpError.new(response.code, response.reason, response)
         end
 
         buffer = ''
         response.body.each do |chunk|
           buffer << chunk
           while (line = buffer.slice!(/.+\n/))
-            yield @format == :json ? WatchNotice.new(JSON.parse(line)) : line.chomp
+            result =
+              case @as
+              when :ros then WatchNotice.new(JSON.parse(line))
+              when :raw then line.chomp
+              else raise NotImplementedError, "Unsupported as #{@as.inspect}"
+              end
+            yield(result)
           end
         end
       rescue IOError, Errno::EBADF
@@ -40,8 +46,10 @@ module Kubeclient
 
       def build_client
         if @http_options[:basic_auth_user] && @http_options[:basic_auth_password]
-          HTTP.basic_auth(user: @http_options[:basic_auth_user],
-                          pass: @http_options[:basic_auth_password])
+          HTTP.basic_auth(
+            user: @http_options[:basic_auth_user],
+            pass: @http_options[:basic_auth_password]
+          )
         else
           HTTP::Client.new
         end
@@ -66,12 +74,11 @@ module Kubeclient
         }
         if @http_options[:ssl]
           client_options[:ssl] = @http_options[:ssl]
-          client_options[:ssl_socket_class] =
-              @http_options[:ssl_socket_class] if @http_options[:ssl_socket_class]
+          socket_option = :ssl_socket_class
         else
-          client_options[:socket_class] =
-              @http_options[:socket_class] if @http_options[:socket_class]
+          socket_option = :socket_class
         end
+        client_options[socket_option] = @http_options[socket_option] if @http_options[socket_option]
         client_options
       end
     end

data/test/test_common.rb

@@ -1,9 +1,9 @@
-require 'test_helper'
+require_relative 'test_helper'
 
 # Unit tests for the common module
 class CommonTest < MiniTest::Test
   def test_underscore_entity
-    %w(
+    %w[
       Pod pod
       Service service
       ReplicationController replication_controller
@@ -25,7 +25,7 @@ class CommonTest < MiniTest::Test
       BuildConfig build_config
       Image image
       ImageStream image_stream
-    ).each_slice(2) do |singular, plural|
+    ].each_slice(2) do |singular, plural|
       assert_equal(Kubeclient::ClientMixin.underscore_entity(singular), plural)
     end
   end

data/test/test_component_status.rb

@@ -1,28 +1,30 @@
-require 'test_helper'
+require_relative 'test_helper'
 
 # ComponentStatus tests
 class TestComponentStatus < MiniTest::Test
   def test_get_from_json_v3
     stub_request(:get, %r{/componentstatuses})
-      .to_return(body: open_test_file('component_status.json'),
-                 status: 200)
+      .to_return(body: open_test_file('component_status.json'), status: 200)
     stub_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
+      .to_return(body: open_test_file('core_api_resource_list.json'), status: 200)
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
-    component_status = client.get_component_status 'etcd-0', 'default'
+    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
+    component_status = client.get_component_status('etcd-0', 'default')
 
-    assert_instance_of(Kubeclient::ComponentStatus, component_status)
+    assert_instance_of(Kubeclient::Resource, component_status)
     assert_equal('etcd-0', component_status.metadata.name)
     assert_equal('Healthy', component_status.conditions[0].type)
     assert_equal('True', component_status.conditions[0].status)
 
-    assert_requested(:get,
-                     'http://localhost:8080/api/v1',
-                     times: 1)
-    assert_requested(:get,
-                     'http://localhost:8080/api/v1/namespaces/default/componentstatuses/etcd-0',
-                     times: 1)
+    assert_requested(
+      :get,
+      'http://localhost:8080/api/v1',
+      times: 1
+    )
+    assert_requested(
+      :get,
+      'http://localhost:8080/api/v1/namespaces/default/componentstatuses/etcd-0',
+      times: 1
+    )
   end
 end

data/test/test_config.rb

@@ -1,31 +1,27 @@
-require 'test_helper'
-
-def test_config_file(name)
-  File.new(File.join(File.dirname(__FILE__), 'config', name))
-end
+require_relative 'test_helper'
 
 # Testing Kubernetes client configuration
-class KubeClientConfigTest < MiniTest::Test
+class KubeclientConfigTest < MiniTest::Test
   def test_allinone
-    config = Kubeclient::Config.read(test_config_file('allinone.kubeconfig'))
+    config = Kubeclient::Config.read(config_file('allinone.kubeconfig'))
     assert_equal(['default/localhost:8443/system:admin'], config.contexts)
     check_context(config.context, ssl: true)
   end
 
   def test_external
-    config = Kubeclient::Config.read(test_config_file('external.kubeconfig'))
+    config = Kubeclient::Config.read(config_file('external.kubeconfig'))
     assert_equal(['default/localhost:8443/system:admin'], config.contexts)
     check_context(config.context, ssl: true)
   end
 
   def test_nouser
-    config = Kubeclient::Config.read(test_config_file('nouser.kubeconfig'))
+    config = Kubeclient::Config.read(config_file('nouser.kubeconfig'))
     assert_equal(['default/localhost:8443/nouser'], config.contexts)
     check_context(config.context, ssl: false)
   end
 
   def test_user_token
-    config = Kubeclient::Config.read(test_config_file('userauth.kubeconfig'))
+    config = Kubeclient::Config.read(config_file('userauth.kubeconfig'))
     assert_equal(['localhost/system:admin:token', 'localhost/system:admin:userpass'],
                  config.contexts)
     context = config.context('localhost/system:admin:token')
@@ -34,7 +30,7 @@ class KubeClientConfigTest < MiniTest::Test
   end
 
   def test_user_password
-    config = Kubeclient::Config.read(test_config_file('userauth.kubeconfig'))
+    config = Kubeclient::Config.read(config_file('userauth.kubeconfig'))
     assert_equal(['localhost/system:admin:token', 'localhost/system:admin:userpass'],
                  config.contexts)
     context = config.context('localhost/system:admin:userpass')
@@ -69,4 +65,8 @@ class KubeClientConfigTest < MiniTest::Test
       assert_equal(OpenSSL::SSL::VERIFY_NONE, context.ssl_options[:verify_ssl])
     end
   end
+
+  def config_file(name)
+    File.new(File.join(File.dirname(__FILE__), 'config', name))
+  end
 end

data/test/test_endpoint.rb

@@ -1,31 +1,35 @@
-require 'test_helper'
+require_relative 'test_helper'
 
 # Endpoint entity tests
 class TestEndpoint < MiniTest::Test
   def test_create_endpoint
     stub_request(:get, %r{/api/v1$})
-      .to_return(body: open_test_file('core_api_resource_list.json'),
-                 status: 200)
+      .to_return(
+        body: open_test_file('core_api_resource_list.json'),
+        status: 200
+      )
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
+    client = Kubeclient::Client.new('http://localhost:8080/api/', 'v1')
     testing_ep = Kubeclient::Resource.new
     testing_ep.metadata = {}
     testing_ep.metadata.name = 'myendpoint'
     testing_ep.metadata.namespace = 'default'
-    testing_ep.subsets = [{ 'addresses' => [{ 'ip' => '172.17.0.25' }], 'ports' =>
-                              [{ 'name' => 'https',
-                                 'port' => 6443,
-                                 'protocol' => 'TCP' }] }]
+    testing_ep.subsets = [
+      {
+        'addresses' => [{ 'ip' => '172.17.0.25' }],
+        'ports' => [{ 'name' => 'https', 'port' => 6443, 'protocol' => 'TCP' }]
+      }
+    ]
 
-    req_body = "{\"metadata\":{\"name\":\"myendpoint\",\"namespace\":\"default\"}," \
-        "\"subsets\":[{\"addresses\":[{\"ip\":\"172.17.0.25\"}],\"ports\":[{\"name\":\"https\"," \
-    "\"port\":6443,\"protocol\":\"TCP\"}]}],\"kind\":\"Endpoints\",\"apiVersion\":\"v1\"}"
+    req_body = '{"metadata":{"name":"myendpoint","namespace":"default"},' \
+      '"subsets":[{"addresses":[{"ip":"172.17.0.25"}],"ports":[{"name":"https",' \
+      '"port":6443,"protocol":"TCP"}]}],"kind":"Endpoints","apiVersion":"v1"}'
 
     stub_request(:post, 'http://localhost:8080/api/v1/namespaces/default/endpoints')
       .with(body: req_body)
       .to_return(body: open_test_file('created_endpoint.json'), status: 201)
 
-    created_ep = client.create_endpoint testing_ep
+    created_ep = client.create_endpoint(testing_ep)
     assert_equal('Endpoints', created_ep.kind)
   end
 end

data/test/test_guestbook_go.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require_relative 'test_helper'
 require 'vcr'
 
 # creation of google's example of guest book
@@ -6,12 +6,12 @@ class CreateGuestbookGo < MiniTest::Test
   def test_create_guestbook_entities
     VCR.configure do |c|
       c.cassette_library_dir = 'test/cassettes'
-      c.hook_into :webmock
+      c.hook_into(:webmock)
     end
 
     # WebMock.allow_net_connect!
     VCR.use_cassette('kubernetes_guestbook') do # , record: :new_episodes) do
-      client = Kubeclient::Client.new 'http://10.35.0.23:8080/api/', 'v1'
+      client = Kubeclient::Client.new('http://10.35.0.23:8080/api/', 'v1')
 
       testing_ns = Kubeclient::Resource.new
       testing_ns.metadata = {}
@@ -19,12 +19,16 @@ class CreateGuestbookGo < MiniTest::Test
 
       # delete in case they existed before so creation can be tested
       delete_namespace(client, testing_ns.metadata.name)
-      delete_services(client, testing_ns.metadata.name,
-                      ['guestbook', 'redis-master', 'redis-slave'])
-      delete_replication_controllers(client, testing_ns.metadata.name,
-                                     ['guestbook', 'redis-master', 'redis-slave'])
-
-      client.create_namespace testing_ns
+      delete_services(
+        client, testing_ns.metadata.name,
+        ['guestbook', 'redis-master', 'redis-slave']
+      )
+      delete_replication_controllers(
+        client, testing_ns.metadata.name,
+        ['guestbook', 'redis-master', 'redis-slave']
+      )
+
+      client.create_namespace(testing_ns)
       services = create_services(client, testing_ns.metadata.name)
       replicators = create_replication_controllers(client, testing_ns.metadata.name)
 
@@ -35,15 +39,14 @@ class CreateGuestbookGo < MiniTest::Test
       delete_services(client, testing_ns.metadata.name, services)
       delete_replication_controllers(client, testing_ns.metadata.name, replicators)
 
-      client.delete_namespace testing_ns.metadata.name
+      client.delete_namespace(testing_ns.metadata.name)
     end
   end
 
   def delete_namespace(client, namespace_name)
-    client.delete_namespace namespace_name
-    rescue KubeException => exception
-      assert_instance_of(KubeException, exception)
-      assert_equal(404, exception.error_code)
+    client.delete_namespace(namespace_name)
+  rescue Kubeclient::ResourceNotFoundError => exception
+    assert_equal(404, exception.error_code)
   end
 
   def get_namespaces(client)
@@ -62,16 +65,16 @@ class CreateGuestbookGo < MiniTest::Test
   end
 
   def create_services(client, ns)
-    guestbook_service = client.create_service guestbook_service(ns)
-    redis_service = client.create_service redis_service(ns)
-    redis_slave_service = client.create_service redis_slave_service(ns)
+    guestbook_service = client.create_service(guestbook_service(ns))
+    redis_service = client.create_service(redis_service(ns))
+    redis_slave_service = client.create_service(redis_slave_service(ns))
     [guestbook_service, redis_service, redis_slave_service]
   end
 
   def create_replication_controllers(client, namespace)
-    rc = client.create_replication_controller guestbook_rc(namespace)
-    rc2 = client.create_replication_controller redis_master_rc(namespace)
-    rc3 = client.create_replication_controller redis_slave_rc(namespace)
+    rc = client.create_replication_controller(guestbook_rc(namespace))
+    rc2 = client.create_replication_controller(redis_master_rc(namespace))
+    rc3 = client.create_replication_controller(redis_slave_rc(namespace))
     [rc, rc2, rc3]
   end
 
@@ -79,14 +82,13 @@ class CreateGuestbookGo < MiniTest::Test
     # if the entity is not found, no need to fail the test
     services.each do |service|
       begin
-        if service.instance_of?(Kubeclient::Service)
-          client.delete_service service.metadata.name, namespace
+        if service.instance_of?(Kubeclient::Resource)
+          client.delete_service(service.metadata.name, namespace)
         else
           # it's just a string - service name
-          client.delete_service service, namespace
+          client.delete_service(service, namespace)
         end
-      rescue KubeException => exception
-        assert_instance_of(KubeException, exception)
+      rescue Kubeclient::ResourceNotFoundError => exception
         assert_equal(404, exception.error_code)
       end
     end
@@ -96,14 +98,13 @@ class CreateGuestbookGo < MiniTest::Test
     # if the entity is not found, no need to fail the test
     replication_controllers.each do |rc|
       begin
-        if rc.instance_of?(Kubeclient::ReplicationController)
-          client.delete_replication_controller rc.metadata.name, namespace
+        if rc.instance_of?(Kubeclient::Resource)
+          client.delete_replication_controller(rc.metadata.name, namespace)
         else
           # it's just a string - rc name
-          client.delete_replication_controller rc, namespace
+          client.delete_replication_controller(rc, namespace)
         end
-      rescue KubeException => exception
-        assert_instance_of(KubeException, exception)
+      rescue Kubeclient::ResourceNotFoundError => exception
         assert_equal(404, exception.error_code)
       end
     end
@@ -112,7 +113,7 @@ class CreateGuestbookGo < MiniTest::Test
   private
 
   def construct_base_rc(namespace)
-    rc = Kubeclient::ReplicationController.new
+    rc = Kubeclient::Resource.new
     rc.metadata = {}
     rc.metadata.namespace = namespace
     rc.metadata.labels = {}
@@ -135,10 +136,14 @@ class CreateGuestbookGo < MiniTest::Test
     rc.spec.selector.role = 'master'
     rc.spec.template.metadata.labels.app = 'redis'
     rc.spec.template.metadata.labels.role = 'master'
-    rc.spec.template.spec.containers = [{ 'name' => 'redis-master',
-                                          'image' => 'redis',
-                                          'ports' => [{ 'name' => 'redis-server',
-                                                        'containerPort' => 6379 }] }]
+    rc.spec.template.spec.containers = [{
+      'name' => 'redis-master',
+      'image' => 'redis',
+      'ports' => [{
+        'name' => 'redis-server',
+        'containerPort' => 6379
+      }]
+    }]
     rc
   end
 
@@ -152,11 +157,14 @@ class CreateGuestbookGo < MiniTest::Test
     rc.spec.selector.role = 'slave'
     rc.spec.template.metadata.labels.app = 'redis'
     rc.spec.template.metadata.labels.role = 'slave'
-    rc.spec.template.spec.containers = [{ 'name'          => 'redis-slave',
-                                          'image'         => 'kubernetes/redis-slave:v2',
-                                          'ports'         => [{ 'name'          => 'redis-server',
-                                                                'containerPort' => 6379 }
-                                                             ] }]
+    rc.spec.template.spec.containers = [{
+      'name'          => 'redis-slave',
+      'image'         => 'kubernetes/redis-slave:v2',
+      'ports'         => [{
+        'name'          => 'redis-server',
+        'containerPort' => 6379
+      }]
+    }]
     rc
   end
 
@@ -168,17 +176,23 @@ class CreateGuestbookGo < MiniTest::Test
     rc.spec.replicas = 3
     rc.spec.selector.app = 'guestbook'
     rc.spec.template.metadata.labels.app = 'guestbook'
-    rc.spec.template.spec.containers = [{ 'name'     => 'guestbook',
-                                          'image'    => 'kubernetes/guestbook:v2',
-                                          'ports'    => [{ 'name'          => 'http-server',
-                                                           'containerPort' => 3000 }]
-                                        }]
-
+    rc.spec.template.spec.containers = [
+      {
+        'name'     => 'guestbook',
+        'image'    => 'kubernetes/guestbook:v2',
+        'ports'    => [
+          {
+            'name'          => 'http-server',
+            'containerPort' => 3000
+          }
+        ]
+      }
+    ]
     rc
   end
 
   def base_service(namespace)
-    our_service = Kubeclient::Service.new
+    our_service = Kubeclient::Resource.new
     our_service.metadata = {}
     our_service.metadata.namespace = namespace
     our_service.metadata.labels = {}
@@ -192,11 +206,7 @@ class CreateGuestbookGo < MiniTest::Test
     our_service.metadata.name = 'redis-slave'
     our_service.metadata.labels.app = 'redis'
     our_service.metadata.labels.role = 'slave'
-
-    our_service.spec.ports = [{ 'port' => 6379,
-                                'targetPort' => 'redis-server'
-                              }]
-
+    our_service.spec.ports = [{ 'port' => 6379, 'targetPort' => 'redis-server' }]
     our_service.spec.selector.app = 'redis'
     our_service.spec.selector.role = 'slave'
     our_service
@@ -207,11 +217,7 @@ class CreateGuestbookGo < MiniTest::Test
     our_service.metadata.name = 'redis-master'
     our_service.metadata.labels.app = 'redis'
     our_service.metadata.labels.role = 'master'
-
-    our_service.spec.ports = [{ 'port' => 6379,
-                                'targetPort' => 'redis-server'
-                              }]
-
+    our_service.spec.ports = [{ 'port' => 6379, 'targetPort' => 'redis-server' }]
     our_service.spec.selector.app = 'redis'
     our_service.spec.selector.role = 'master'
     our_service
@@ -221,11 +227,7 @@ class CreateGuestbookGo < MiniTest::Test
     our_service = base_service(namespace)
     our_service.metadata.name = 'guestbook'
     our_service.metadata.labels.name = 'guestbook'
-
-    our_service.spec.ports = [{ 'port' => 3000,
-                                'targetPort' => 'http-server'
-                              }]
-
+    our_service.spec.ports = [{ 'port' => 3000, 'targetPort' => 'http-server' }]
     our_service.spec.selector.app = 'guestbook'
     our_service.type = 'LoadBalancer'
     our_service