kubeclient 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: be8f06e6c46d5f6e8f202ff4f0b36d6474649b45
-  data.tar.gz: 678a768f43fab92d1e5368da223fb6a8f193b628
+  metadata.gz: 44f9ae79ede59af09899f793e1ed033432e53961
+  data.tar.gz: 91bd146bc7163d9b63ef077d36282c3f3d4d6e31
 SHA512:
-  metadata.gz: 6195902eb2f834c05346d9c6b8f8c200fd44e253451fb9b376486325804d700eddb50d7e35fdb4ba3e5ae48e338db4fea7e6ad156ca84e0033ba1723a7b550b5
-  data.tar.gz: ec74ebf40164b703d4442c3c77fd715ce1f662392e76ef4bc7ac448ae5a76f5937313dd5503fb361c03e1970b4576ef5776e4e3c8e6e37a871481db18c03d323
+  metadata.gz: a228a944f9d2ef70578ab7ad97b5ed1a0636b8b2bcc9e3553d18e5a97c064d2f4135e0803babcf3774e4c020d9ebeb199a0179fa8725ab53e6c91c7bb4a283ac
+  data.tar.gz: b770ad33ad96267dbea66d3cd6e3bff15968dd91c2f1f9a540bcc96936762264667c8ea1f19c186c68ba7b017a077dbedf43b2ebef3ea0cd61729080bf14d021

data/README.md

@@ -30,9 +30,9 @@ Or install it yourself as:
 Initialize the client: <br>
 `client = Kubeclient::Client.new 'http://localhost:8080/api/' , "v1beta3"`
 
-or for the v3:
+Or without specifying version (it will be set by default to "v1beta3"
 
-`client = Kubeclient::Client.new 'http://localhost:8080/api/' , "v1beta3"`
+`client = Kubeclient::Client.new 'http://localhost:8080/api/' `
 
 Another option is to initialize the client with URI object:
 
@@ -101,7 +101,7 @@ The below example is for v1beta3 <br>
 
 6. all_entities - Returns a hash with 7 keys (node, service, pod, replication_controller, namespace, endpoint and event). Each key points to an EntityList of same type. This method
  is a convenience method instead of calling each entity's get method separately. <br>
-`client.get_all_entities`
+`client.all_entities`
 
 7. Receive entity updates <br>
 It is possible to receive live update notices watching the relevant entities:

data/lib/kubeclient.rb

@@ -6,10 +6,11 @@ require 'kubeclient/entity_list'
 require 'kubeclient/kube_exception'
 require 'kubeclient/watch_notice'
 require 'kubeclient/watch_stream'
+require 'kubeclient/common'
 
 module Kubeclient
   # Kubernetes Client
-  class Client
+  class Client < Common::Client
     attr_reader :api_endpoint
 
     # Dynamically creating classes definitions (class Pod, class Service, etc.),
@@ -23,186 +24,13 @@ module Kubeclient
     end
 
     def initialize(uri, version = 'v1beta3')
-      @api_endpoint = (uri.is_a? URI) ? uri : URI.parse(uri)
-      @api_endpoint.path = '/api/' if @api_endpoint.path.empty?
-      unless @api_endpoint.path.end_with? '/'
-        @api_endpoint.path = @api_endpoint.path + '/'
-      end
+      handle_uri(uri, '/api')
       @api_version = version
       ssl_options
     end
 
-    def rest_client
-      @rest_client ||= begin
-        options = {
-          ssl_ca_file:      @ssl_options[:ca_file],
-          verify_ssl:       @ssl_options[:verify_ssl],
-          ssl_client_cert:  @ssl_options[:client_cert],
-          ssl_client_key:   @ssl_options[:client_key]
-        }
-        endpoint_with_version = @api_endpoint
-                                .merge("#{@api_endpoint.path}#{@api_version}")
-        RestClient::Resource.new(endpoint_with_version, options)
-      end
-    end
-
-    private
-
-    def handle_exception
-      yield
-    rescue RestClient::Exception => e
-      begin
-        err_message = JSON.parse(e.response)['message']
-      rescue JSON::ParserError
-        err_message = e.message
-      end
-      raise KubeException.new(e.http_code, err_message)
-    end
-
-    def get_entities(entity_type, klass, options)
-      params = {}
-      if options[:label_selector]
-        params['label-selector'] = options[:label_selector]
-      end
-
-      # TODO: namespace support?
-      response = handle_exception do
-        rest_client[get_resource_name(entity_type)].get(params: params)
-      end
-
-      result = JSON.parse(response)
-
-      resource_version = result.fetch('resourceVersion', nil)
-      if resource_version.nil?
-        resource_version =
-          result.fetch('metadata', {}).fetch('resourceVersion', nil)
-      end
-
-      collection = result['items'].map { |item| new_entity(item, klass) }
-
-      EntityList.new(entity_type, resource_version, collection)
-    end
-
-    def watch_entities(entity_type, resource_version = nil)
-      resource_name = get_resource_name(entity_type.to_s)
-
-      uri = @api_endpoint
-            .merge("#{@api_endpoint.path}#{@api_version}/watch/" \
-                      "#{resource_name}")
-
-      unless resource_version.nil?
-        uri.query = URI.encode_www_form('resourceVersion' => resource_version)
-      end
-
-      options = {
-        use_ssl:      uri.scheme == 'https',
-        ca_file:      @ssl_options[:ca_file],
-        verify_ssl:   @ssl_options[:verify_ssl],
-        client_cert:  @ssl_options[:client_cert],
-        client_key:   @ssl_options[:client_key]
-      }
-
-      WatchStream.new(uri, options)
-    end
-
-    def get_entity(entity_type, klass, id)
-      response = handle_exception do
-        rest_client[get_resource_name(entity_type) + "/#{id}"].get
-      end
-      result = JSON.parse(response)
-      new_entity(result, klass)
-    end
-
-    def delete_entity(entity_type, id)
-      handle_exception do
-        rest_client[get_resource_name(entity_type) + "/#{id}"].delete
-      end
-    end
-
-    def create_entity(entity_type, entity_config)
-      # to_hash should be called because of issue #9 in recursive open
-      # struct
-      hash = entity_config.to_hash
-      handle_exception do
-        rest_client[get_resource_name(entity_type)].post(hash.to_json)
-      end
-    end
-
-    def update_entity(entity_type, entity_config)
-      id = entity_config.id
-      # to_hash should be called because of issue #9 in recursive open
-      # struct
-      hash = entity_config.to_hash
-      # TODO: temporary solution to delete id till this issue is solved
-      # https://github.com/GoogleCloudPlatform/kubernetes/issues/3085
-      hash.delete(:id)
-      handle_exception do
-        rest_client[get_resource_name(entity_type) + "/#{id}"].put(hash.to_json)
-      end
-    end
-
-    protected
-
-    def new_entity(hash, klass)
-      klass.new(hash)
-    end
-
-    def get_resource_name(entity_type)
-      entity_type.pluralize.downcase
-    end
-
-    public
-
-    def ssl_options(client_cert: nil, client_key: nil, ca_file: nil,
-                    verify_ssl: OpenSSL::SSL::VERIFY_PEER)
-      @ssl_options = {
-        ca_file:      ca_file,
-        verify_ssl:   verify_ssl,
-        client_cert:  client_cert,
-        client_key:   client_key
-      }
-    end
-
-    ENTITY_TYPES.each do |klass, entity_type|
-      entity_name = entity_type.underscore
-      entity_name_plural = entity_name.pluralize
-
-      # get all entities of a type e.g. get_nodes, get_pods, etc.
-      define_method("get_#{entity_name_plural}") do |options = {}|
-        get_entities(entity_type, klass, options)
-      end
-
-      # watch all entities of a type e.g. watch_nodes, watch_pods, etc.
-      define_method("watch_#{entity_name_plural}") do |resource_version = nil|
-        watch_entities(entity_type, resource_version)
-      end
-
-      # get a single entity of a specific type by id
-      define_method("get_#{entity_name}") do |id|
-        get_entity(entity_type, klass, id)
-      end
-
-      define_method("delete_#{entity_name}") do |id|
-        delete_entity(entity_type, id)
-      end
-
-      define_method("create_#{entity_name}") do |entity_config|
-        create_entity(entity_type, entity_config)
-      end
-
-      define_method("update_#{entity_name}") do |entity_config|
-        update_entity(entity_type, entity_config)
-      end
-    end
-
     def all_entities
-      ENTITY_TYPES.each_with_object({}) do |(_, entity_type), result_hash|
-        # method call for get each entities
-        # build hash of entity name to array of the entities
-        method_name = "get_#{entity_type.underscore.pluralize}"
-        key_name = entity_type.underscore
-        result_hash[key_name] = send(method_name)
-      end
+      retrieve_all_entities(ENTITY_TYPES)
     end
 
     def api
@@ -216,5 +44,7 @@ module Kubeclient
       result = api
       result.is_a?(Hash) && result['versions'].is_a?(Array)
     end
+
+    define_entity_methods(ENTITY_TYPES)
   end
 end

data/lib/kubeclient/common.rb

@@ -0,0 +1,191 @@
+require 'json'
+require 'rest-client'
+module Kubeclient
+  module Common
+    # Common methods
+    class Client
+      def handle_exception
+        yield
+      rescue RestClient::Exception => e
+        begin
+          err_message = JSON.parse(e.response)['message']
+        rescue JSON::ParserError
+          err_message = e.message
+        end
+        raise KubeException.new(e.http_code, err_message)
+      end
+
+      def handle_uri(uri, path)
+        @api_endpoint = (uri.is_a? URI) ? uri : URI.parse(uri)
+        @api_endpoint.path = path if @api_endpoint.path.empty?
+        @api_endpoint.path = @api_endpoint.path.chop \
+                           if @api_endpoint.path.end_with? '/'
+      end
+
+      public
+
+      def self.define_entity_methods(entity_types)
+        entity_types.each do |klass, entity_type|
+          entity_name = entity_type.underscore
+          entity_name_plural = entity_name.pluralize
+
+          # get all entities of a type e.g. get_nodes, get_pods, etc.
+          define_method("get_#{entity_name_plural}") do |options = {}|
+            get_entities(entity_type, klass, options)
+          end
+
+          # watch all entities of a type e.g. watch_nodes, watch_pods, etc.
+          define_method("watch_#{entity_name_plural}") \
+          do |resource_version = nil|
+            watch_entities(entity_type, resource_version)
+          end
+
+          # get a single entity of a specific type by id
+          define_method("get_#{entity_name}") do |id|
+            get_entity(entity_type, klass, id)
+          end
+
+          define_method("delete_#{entity_name}") do |id|
+            delete_entity(entity_type, id)
+          end
+
+          define_method("create_#{entity_name}") do |entity_config|
+            create_entity(entity_type, entity_config)
+          end
+
+          define_method("update_#{entity_name}") do |entity_config|
+            update_entity(entity_type, entity_config)
+          end
+        end
+      end
+
+      def rest_client
+        @rest_client ||= begin
+          options = {
+            ssl_ca_file: @ssl_options[:ca_file],
+            verify_ssl: @ssl_options[:verify_ssl],
+            ssl_client_cert: @ssl_options[:client_cert],
+            ssl_client_key: @ssl_options[:client_key]
+          }
+          endpoint_with_version = @api_endpoint.merge(@api_endpoint.path + '/' \
+                                                      + @api_version)
+          RestClient::Resource.new(endpoint_with_version, options)
+        end
+      end
+
+      def watch_entities(entity_type, resource_version = nil)
+        resource_name = get_resource_name(entity_type.to_s)
+
+        uri = @api_endpoint.merge(@api_endpoint.path + '/' + @api_version \
+                                  + '/watch/' + resource_name)
+
+        unless resource_version.nil?
+          uri.query = URI.encode_www_form('resourceVersion' => resource_version)
+        end
+
+        options = {
+          use_ssl: uri.scheme == 'https',
+          ca_file: @ssl_options[:ca_file],
+          verify_ssl: @ssl_options[:verify_ssl],
+          client_cert: @ssl_options[:client_cert],
+          client_key: @ssl_options[:client_key]
+        }
+
+        WatchStream.new(uri, options)
+      end
+
+      def get_entities(entity_type, klass, options)
+        params = {}
+        if options[:label_selector]
+          params['label-selector'] = options[:label_selector]
+        end
+
+        # TODO: namespace support?
+        response = handle_exception do
+          rest_client[get_resource_name(entity_type)].get(params: params)
+        end
+
+        result = JSON.parse(response)
+
+        resource_version = result.fetch('resourceVersion', nil)
+        if resource_version.nil?
+          resource_version =
+              result.fetch('metadata', {}).fetch('resourceVersion', nil)
+        end
+
+        collection = result['items'].map { |item| new_entity(item, klass) }
+
+        EntityList.new(entity_type, resource_version, collection)
+      end
+
+      def get_entity(entity_type, klass, id)
+        response = handle_exception do
+          rest_client[get_resource_name(entity_type) + "/#{id}"].get
+        end
+        result = JSON.parse(response)
+        new_entity(result, klass)
+      end
+
+      def delete_entity(entity_type, id)
+        handle_exception do
+          rest_client[get_resource_name(entity_type) + "/#{id}"].delete
+        end
+      end
+
+      def create_entity(entity_type, entity_config)
+        # to_hash should be called because of issue #9 in recursive open
+        # struct
+        hash = entity_config.to_hash
+        handle_exception do
+          rest_client[get_resource_name(entity_type)].post(hash.to_json)
+        end
+      end
+
+      def update_entity(entity_type, entity_config)
+        id = entity_config.id
+        # to_hash should be called because of issue #9 in recursive open
+        # struct
+        hash = entity_config.to_hash
+        # TODO: temporary solution to delete id till this issue is solved
+        # https://github.com/GoogleCloudPlatform/kubernetes/issues/3085
+        hash.delete(:id)
+        handle_exception do
+          rest_client[get_resource_name(entity_type) + "/#{id}"]
+            .put(hash.to_json)
+        end
+      end
+
+      def new_entity(hash, klass)
+        klass.new(hash)
+      end
+
+      def retrieve_all_entities(entity_types)
+        entity_types.each_with_object({}) do |(_, entity_type), result_hash|
+          # method call for get each entities
+          # build hash of entity name to array of the entities
+          method_name = "get_#{entity_type.underscore.pluralize}"
+          key_name = entity_type.underscore
+          result_hash[key_name] = send(method_name)
+        end
+      end
+
+      def get_resource_name(entity_type)
+        if @api_version == 'v1beta1'
+          entity_type.pluralize.camelize(:lower)
+        else
+          entity_type.pluralize.downcase
+        end
+      end
+
+      def ssl_options(client_cert: nil, client_key: nil, ca_file: nil,
+                      verify_ssl: OpenSSL::SSL::VERIFY_PEER)
+        @ssl_options = {
+          ca_file: ca_file,
+          verify_ssl: verify_ssl,
+          client_cert: client_cert,
+          client_key: client_key
+        }
+      end
+    end
+  end
+end

data/lib/kubeclient/entity_list.rb

@@ -1,15 +1,16 @@
 require 'delegate'
-
 module Kubeclient
-  # Kubernetes Entity List
-  class EntityList < DelegateClass(Array)
-    attr_reader :kind, :resourceVersion
+  module Common
+    # Kubernetes Entity List
+    class EntityList < DelegateClass(Array)
+      attr_reader :kind, :resourceVersion
 
-    def initialize(kind, resource_version, list)
-      @kind = kind
-      # rubocop:disable Style/VariableName
-      @resourceVersion = resource_version
-      super(list)
+      def initialize(kind, resource_version, list)
+        @kind = kind
+        # rubocop:disable Style/VariableName
+        @resourceVersion = resource_version
+        super(list)
+      end
     end
   end
 end

data/lib/kubeclient/version.rb

@@ -1,4 +1,4 @@
 # Kubernetes REST-API Client
 module Kubeclient
-  VERSION = '0.1.8'
+  VERSION = '0.1.9'
 end

data/lib/kubeclient/watch_notice.rb

@@ -1,4 +1,7 @@
 require 'recursive_open_struct'
-
-class WatchNotice <  RecursiveOpenStruct
+module Kubeclient
+  module Common
+    class WatchNotice < RecursiveOpenStruct
+    end
+  end
 end

data/lib/kubeclient/watch_stream.rb

@@ -1,40 +1,41 @@
 require 'json'
 require 'net/http'
-
 module Kubeclient
-  # HTTP Stream used to watch changes on entities
-  class WatchStream
-    def initialize(uri, options)
-      @uri = uri
-      @http = nil
-      @options = options.merge(read_timeout: nil)
-    end
+  module Common
+    # HTTP Stream used to watch changes on entities
+    class WatchStream
+      def initialize(uri, options)
+        @uri = uri
+        @http = nil
+        @options = options.merge(read_timeout: nil)
+      end
 
-    def each
-      @finished = false
-      @http = Net::HTTP.start(@uri.host, @uri.port, @options)
+      def each
+        @finished = false
+        @http = Net::HTTP.start(@uri.host, @uri.port, @options)
 
-      buffer = ''
-      request = Net::HTTP::Get.new(@uri)
+        buffer = ''
+        request = Net::HTTP::Get.new(@uri)
 
-      @http.request(request) do |response|
-        unless response.is_a? Net::HTTPSuccess
-          fail KubeException.new(response.code, response.message)
-        end
-        response.read_body do |chunk|
-          buffer << chunk
-          while (line = buffer.slice!(/.+\n/))
-            yield WatchNotice.new(JSON.parse(line))
+        @http.request(request) do |response|
+          unless response.is_a? Net::HTTPSuccess
+            fail KubeException.new(response.code, response.message)
+          end
+          response.read_body do |chunk|
+            buffer << chunk
+            while (line = buffer.slice!(/.+\n/))
+              yield WatchNotice.new(JSON.parse(line))
+            end
           end
         end
+      rescue Errno::EBADF
+        raise unless @finished
       end
-    rescue Errno::EBADF
-      raise unless @finished
-    end
 
-    def finish
-      @finished = true
-      @http.finish if !@http.nil? && @http.started?
+      def finish
+        @finished = true
+        @http.finish if !@http.nil? && @http.started?
+      end
     end
   end
 end

data/test/test_kubeclient.rb

@@ -66,7 +66,7 @@ class KubeClientTest < MiniTest::Test
   end
 
   def test_api
-    stub_request(:get, 'http://localhost:8080/api/')
+    stub_request(:get, 'http://localhost:8080/api')
       .to_return(status: 200, body: open_test_json_file('versions_list.json'))
 
     client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
@@ -75,34 +75,34 @@ class KubeClientTest < MiniTest::Test
   end
 
   def test_api_valid
-    stub_request(:get, 'http://localhost:8080/api/')
+    stub_request(:get, 'http://localhost:8080/api')
       .to_return(status: 200, body: open_test_json_file('versions_list.json'))
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
+    client = Kubeclient::Client.new 'http://localhost:8080/api/'
     assert client.api_valid?
   end
 
   def test_api_valid_with_invalid_json
-    stub_request(:get, 'http://localhost:8080/api/')
+    stub_request(:get, 'http://localhost:8080/api')
       .to_return(status: 200, body: '{}')
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
+    client = Kubeclient::Client.new 'http://localhost:8080/api/'
     refute client.api_valid?
   end
 
   def test_api_valid_with_bad_endpoint
-    stub_request(:get, 'http://localhost:8080/api/')
+    stub_request(:get, 'http://localhost:8080/api')
       .to_return(status: [404, 'Resource Not Found'])
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
+    client = Kubeclient::Client.new 'http://localhost:8080/api/'
     assert_raises(KubeException) { client.api_valid? }
   end
 
   def test_api_valid_with_non_json
-    stub_request(:get, 'http://localhost:8080/api/')
+    stub_request(:get, 'http://localhost:8080/api')
       .to_return(status: 200, body: '<html></html>')
 
-    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
+    client = Kubeclient::Client.new 'http://localhost:8080/api/'
     assert_raises(JSON::ParserError) { client.api_valid? }
   end
 
@@ -131,7 +131,7 @@ class KubeClientTest < MiniTest::Test
     services = client.get_services
 
     refute_empty(services)
-    assert_instance_of(Kubeclient::EntityList, services)
+    assert_instance_of(Kubeclient::Common::EntityList, services)
     assert_equal('Service', services.kind)
     assert_equal(2, services.size)
     assert_instance_of(Kubeclient::Service, services[0])
@@ -145,7 +145,7 @@ class KubeClientTest < MiniTest::Test
 
     client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
     pods = client.get_pods
-    assert_instance_of(Kubeclient::EntityList, pods)
+    assert_instance_of(Kubeclient::Common::EntityList, pods)
     assert_equal(0, pods.size)
   end
 
@@ -180,12 +180,13 @@ class KubeClientTest < MiniTest::Test
     client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
     result = client.all_entities
     assert_equal(7, result.keys.size)
-    assert_instance_of(Kubeclient::EntityList, result['node'])
-    assert_instance_of(Kubeclient::EntityList, result['service'])
-    assert_instance_of(Kubeclient::EntityList, result['replication_controller'])
-    assert_instance_of(Kubeclient::EntityList, result['pod'])
-    assert_instance_of(Kubeclient::EntityList, result['event'])
-    assert_instance_of(Kubeclient::EntityList, result['namespace'])
+    assert_instance_of(Kubeclient::Common::EntityList, result['node'])
+    assert_instance_of(Kubeclient::Common::EntityList, result['service'])
+    assert_instance_of(Kubeclient::Common::EntityList,
+                       result['replication_controller'])
+    assert_instance_of(Kubeclient::Common::EntityList, result['pod'])
+    assert_instance_of(Kubeclient::Common::EntityList, result['event'])
+    assert_instance_of(Kubeclient::Common::EntityList, result['namespace'])
     assert_instance_of(Kubeclient::Service, result['service'][0])
     assert_instance_of(Kubeclient::Node, result['node'][0])
     assert_instance_of(Kubeclient::Event, result['event'][0])

data/test/test_watch.rb

@@ -16,7 +16,7 @@ class TestWatch < MiniTest::Test
     client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
 
     client.watch_pods.to_enum.with_index do |notice, index|
-      assert_instance_of(WatchNotice, notice)
+      assert_instance_of(Kubeclient::Common::WatchNotice, notice)
       assert_equal(expected[index]['type'], notice.type)
       assert_equal('Pod', notice.object.kind)
       assert_equal('php', notice.object.metadata.name)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kubeclient
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - Alissa Bonas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-26 00:00:00.000000000 Z
+date: 2015-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -152,6 +152,7 @@ files:
 - Rakefile
 - kubeclient.gemspec
 - lib/kubeclient.rb
+- lib/kubeclient/common.rb
 - lib/kubeclient/entity_list.rb
 - lib/kubeclient/kube_exception.rb
 - lib/kubeclient/version.rb