kubeclient 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bc17e4674c3ba30929ff7269036b8ece9c803d27
-  data.tar.gz: 1d6e55bd1fdd2fd7f05e1984cf43e4622c550416
+  metadata.gz: 1c59006602c7c19f25b5fd0d136a5ee84e713a39
+  data.tar.gz: 9df86f3e7570f7af4c6cfa4d7100cfcd4c02b74c
 SHA512:
-  metadata.gz: 17a5534c7be7404ff9e5b376d6c2571582fc6c6ac795301445bdd40361aa27029db856ef0367ce8d52f125fa47e8dc5c4b0c8ec3ab1c8347001e364a17542d41
-  data.tar.gz: 7e847c215609634b3c9d15e961c872aaab6792a95e785d9b2aeb62891acd838d628f257688fa2ea4a81494129eb56e3510106234805dac7fe40004bdea7fd472
+  metadata.gz: 3d7f6d402db1e35486f753178d8fc228cc2eb5b0ed0a6d5adca43dde6b0edd8747b6633df8249bc6247f403e066b73625363864d6865b2758cdad2cebf3ea5f4
+  data.tar.gz: c0124a5a1477a18f3759ba51933ac92528967e1ddc68465777e94f19b67a0f18ff866b7c6a1dff5ac5d125433723e4ab43d68cd5ad3701dbdf8a98ccb0220d80

data/README.md

@@ -38,6 +38,12 @@ Or without specifying version (it will be set by default to "v1")
 client = Kubeclient::Client.new 'http://localhost:8080/api/'
 ```
 
+For A Group Api:
+
+```ruby
+client = Kubeclient::Client.new('http://localhost:8080/apis/batch', 'v1')
+```
+
 Another option is to initialize the client with URI object:
 
 ```ruby
@@ -127,6 +133,8 @@ client = Kubeclient::Client.new 'https://localhost:8443/api/' , 'v1',
                                 auth_options: auth_options
 ```
 
+You can find information about token in [this guide](http://kubernetes.io/docs/user-guide/accessing-the-cluster/) and in [this reference](http://kubernetes.io/docs/admin/authentication/).
+
 You can also use kubeclient with non-blocking sockets such as Celluloid::IO, see [here](https://github.com/httprb/http/wiki/Parallel-requests-with-Celluloid%3A%3AIO) 
 for details. For example:
 
@@ -148,6 +156,49 @@ client = Kubeclient::Client.new('https://localhost:8443/api/',
                                 :http_proxy_uri => proxy_uri)
 ```
 
+### Discovery
+
+Discovery from the kube-apiserver is done lazily on method calls so it would not change behavior.
+
+It can also  be done explicitly:
+```
+client = Kubeclient::Client.new('http://localhost:8080/api', 'v1')
+client.discover
+```
+
+It is possible to check the status of discovery
+```
+unless client.discovered
+  client.discover
+end
+```
+
+### Kubeclient::Config
+
+If you've been using `kubectl` and have a `.kube/config` file, you can auto-populate a config object using `Kubeclient::Config`:
+```ruby
+config = Kubeclient::Config.read('/path/to/.kube/config')
+```
+
+...and then pass that object to `Kubeclient::Client`:
+
+```
+Kubeclient::Client.new(
+	config.context.api_endpoint,
+    config.context.api_version,
+    {
+    	ssl_options: config.context.ssl_options,
+    	auth_options: config.context.auth_options
+    }
+)
+```
+
+You can also load your JSONified config in from an ENV variable (e.g. `KUBE_CONFIG`) like so:
+
+```
+Kubeclient::Config.new(JSON.parse(ENV['KUBE_CONFIG']), nil)
+```
+
 ## Examples:
 
 #### Get all instances of a specific entity type
@@ -330,6 +381,28 @@ watcher.each do |line|
 end
 ```
 
+#### Process a template
+Returns a processed template containing a list of objects to create.
+Input parameter - template (hash)
+Besides its metadata, the template should include a list of objects to be processed and a list of parameters
+to be substituted. Note that for a required parameter that does not provide a generated value, you must supply a value.
+
+```ruby
+client.process_template template
+```
+
+## Upgrading
+
+#### past version 1.2.0
+Replace Specific Entity class references:
+```ruby
+Kubeclient::Service
+```
+with the generic
+```ruby
+Kubeclient::Resource.new
+```
+Where ever possible.
 
 ## Contributing
 

data/kubeclient.gemspec

@@ -26,7 +26,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'vcr'
   spec.add_development_dependency 'rubocop', '= 0.30.0'
   spec.add_dependency 'rest-client'
-  spec.add_dependency 'activesupport'
   spec.add_dependency 'recursive-open-struct', '= 1.0.0'
   spec.add_dependency 'http', '= 0.9.8'
 end

data/lib/kubeclient.rb

@@ -1,7 +1,6 @@
 require 'kubeclient/version'
 require 'json'
 require 'rest-client'
-require 'active_support/inflector'
 require 'kubeclient/entity_list'
 require 'kubeclient/kube_exception'
 require 'kubeclient/watch_notice'
@@ -13,40 +12,20 @@ module Kubeclient
   # Kubernetes Client
   class Client
     include ClientMixin
-    # Dynamically creating classes definitions (class Pod, class Service, etc.),
-    # The classes are extending RecursiveOpenStruct.
-    # This cancels the need to define the classes
-    # manually on every new entity addition,
-    # and especially since currently the class body is empty
-    ENTITY_TYPES = %w(Pod Service ReplicationController Node Event Endpoint
-                      Namespace Secret ResourceQuota LimitRange PersistentVolume
-                      PersistentVolumeClaim ComponentStatus ServiceAccount).map do |et|
-      clazz = Class.new(RecursiveOpenStruct) do
-        def initialize(hash = nil, args = {})
-          args.merge!(recurse_over_arrays: true)
-          super(hash, args)
-        end
-      end
-      [Kubeclient.const_set(et, clazz), et]
-    end
-
-    ClientMixin.define_entity_methods(ENTITY_TYPES)
-
+    # define a multipurpose resource class, available before discovery
+    ClientMixin.resource_class(Kubeclient, 'Resource')
     def initialize(
       uri,
       version = 'v1',
       **options
     )
       initialize_client(
+        Kubeclient,
         uri,
         '/api',
         version,
         options
       )
     end
-
-    def all_entities
-      retrieve_all_entities(ENTITY_TYPES)
-    end
   end
 end

data/lib/kubeclient/common.rb

@@ -4,6 +4,8 @@ module Kubeclient
   # Common methods
   # this is mixed in by other gems
   module ClientMixin
+    ENTITY_METHODS = %w(get watch delete create update patch)
+
     DEFAULT_SSL_OPTIONS = {
       client_cert: nil,
       client_key:  nil,
@@ -26,13 +28,22 @@ module Kubeclient
 
     DEFAULT_HTTP_PROXY_URI = nil
 
+    SEARCH_ARGUMENTS = {
+      'labelSelector' => :label_selector,
+      'fieldSelector' => :field_selector
+    }.freeze
+
+    WATCH_ARGUMENTS = { 'resourceVersion' => :resource_version }.merge!(SEARCH_ARGUMENTS).freeze
+
     attr_reader :api_endpoint
     attr_reader :ssl_options
     attr_reader :auth_options
     attr_reader :http_proxy_uri
     attr_reader :headers
+    attr_reader :discovered
 
     def initialize_client(
+      class_owner,
       uri,
       path,
       version,
@@ -44,6 +55,9 @@ module Kubeclient
       validate_auth_options(auth_options)
       handle_uri(uri, path)
 
+      @class_owner = class_owner
+      @entities = {}
+      @discovered = false
       @api_version = version
       @headers = {}
       @ssl_options = ssl_options
@@ -59,6 +73,28 @@ module Kubeclient
       end
     end
 
+    def method_missing(method_sym, *args, &block)
+      if discovery_needed?(method_sym)
+        discover
+        send(method_sym, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_sym, include_private = false)
+      if discovery_needed?(method_sym)
+        discover
+        respond_to?(method_sym, include_private)
+      else
+        super
+      end
+    end
+
+    def discovery_needed?(method_sym)
+      !@discovered && ENTITY_METHODS.any? { |x| method_sym.to_s.start_with?(x) }
+    end
+
     def handle_exception
       yield
     rescue RestClient::Exception => e
@@ -71,11 +107,44 @@ module Kubeclient
       raise KubeException.new(e.http_code, err_message, e.response)
     end
 
+    def discover
+      @entities = {}
+      result = JSON.parse(handle_exception { rest_client.get(@headers) })
+      result['resources'].each do |resource|
+        next if resource['name'].include?('/')
+        entity = ClientMixin.parse_definition(resource['kind'], resource['name'])
+        @entities[entity.method_names[0]] = entity if entity
+      end
+      define_entity_methods
+      @discovered = true
+    end
+
+    def self.parse_definition(kind, name)
+      # "name": "componentstatuses", networkpolicies, endpoints
+      # "kind": "ComponentStatus" NetworkPolicy, Endpoints
+      # maintain pre group api compatibility for endpoints.
+      # See: https://github.com/kubernetes/kubernetes/issues/8115
+      kind = 'Endpoint' if kind == 'Endpoints'
+
+      prefix = kind[0..kind.rindex(/[A-Z]/)] # NetworkP
+      m = name.match(/^#{prefix.downcase}(.*)$/)
+      m && OpenStruct.new(
+        entity_type:   kind, # ComponentStatus
+        resource_name: name, # componentstatuses
+        method_names:  [
+          ClientMixin.underscore_entity(kind),         # component_status
+          ClientMixin.underscore_entity(prefix) + m[1] # component_statuses
+        ]
+      )
+    end
+
     def handle_uri(uri, path)
       fail ArgumentError, 'Missing uri' unless uri
       @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? '/'
+      components = @api_endpoint.path.to_s.split('/') # ["", "api"] or ["", "apis", batch]
+      @api_group = components.length > 2 ? components[2] + '/' : ''
     end
 
     def build_namespace_prefix(namespace)
@@ -84,51 +153,62 @@ module Kubeclient
 
     public
 
-    def self.define_entity_methods(entity_types)
-      entity_types.each do |klass, entity_type|
-        entity_name = entity_type.underscore
-        entity_name_plural = pluralize_entity(entity_name)
+    def self.resource_class(class_owner, entity_type)
+      class_owner.const_get(entity_type, false)
+    rescue NameError
+      class_owner.const_set(
+        entity_type,
+        Class.new(RecursiveOpenStruct) do
+          def initialize(hash = nil, args = {})
+            args[:recurse_over_arrays] = true
+            super(hash, args)
+          end
+        end
+      )
+    end
 
+    def define_entity_methods
+      @entities.values.each do |entity|
+        klass = ClientMixin.resource_class(@class_owner, entity.entity_type)
         # 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)
+        define_singleton_method("get_#{entity.method_names[1]}") do |options = {}|
+          get_entities(entity.entity_type, klass, entity.resource_name, options)
         end
 
         # watch all entities of a type e.g. watch_nodes, watch_pods, etc.
-        define_method("watch_#{entity_name_plural}") do |options = {}|
+        define_singleton_method("watch_#{entity.method_names[1]}") do |options = {}|
           # This method used to take resource_version as a param, so
           # this conversion is to keep backwards compatibility
           options = { resource_version: options } unless options.is_a?(Hash)
 
-          watch_entities(entity_type, options)
+          watch_entities(entity.resource_name, options)
         end
 
         # get a single entity of a specific type by name
-        define_method("get_#{entity_name}") do |name, namespace = nil|
-          get_entity(entity_type, klass, name, namespace)
+        define_singleton_method("get_#{entity.method_names[0]}") do |name, namespace = nil|
+          get_entity(klass, entity.resource_name, name, namespace)
         end
 
-        define_method("delete_#{entity_name}") do |name, namespace = nil|
-          delete_entity(entity_type, name, namespace)
+        define_singleton_method("delete_#{entity.method_names[0]}") do |name, namespace = nil|
+          delete_entity(entity.resource_name, name, namespace)
         end
 
-        define_method("create_#{entity_name}") do |entity_config|
-          create_entity(entity_type, entity_config, klass)
+        define_singleton_method("create_#{entity.method_names[0]}") do |entity_config|
+          create_entity(entity.entity_type, entity.resource_name, entity_config, klass)
         end
 
-        define_method("update_#{entity_name}") do |entity_config|
-          update_entity(entity_type, entity_config)
+        define_singleton_method("update_#{entity.method_names[0]}") do |entity_config|
+          update_entity(entity.resource_name, entity_config)
         end
 
-        define_method("patch_#{entity_name}") do |name, patch, namespace = nil|
-          patch_entity(entity_type, name, patch, namespace)
+        define_singleton_method("patch_#{entity.method_names[0]}") do |name, patch, namespace = nil|
+          patch_entity(entity.resource_name, name, patch, namespace)
         end
       end
     end
 
-    def self.pluralize_entity(entity_name)
-      return entity_name + 's' if entity_name.end_with? 'quota'
-      entity_name.pluralize
+    def self.underscore_entity(entity_name)
+      entity_name.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
     end
 
     def create_rest_client(path = nil)
@@ -158,17 +238,16 @@ module Kubeclient
     #   :label_selector - a selector to restrict the list of returned objects by their labels.
     #   :field_selector - a selector to restrict the list of returned objects by their fields.
     #   :resource_version - shows changes that occur after that particular version of a resource.
-    def watch_entities(entity_type, options = {})
+    def watch_entities(resource_name, options = {})
       ns = build_namespace_prefix(options[:namespace])
 
-      path = "watch/#{ns}#{resource_name(entity_type.to_s)}"
+      path = "watch/#{ns}#{resource_name}"
       path += "/#{options[:name]}" if options[:name]
       uri = @api_endpoint.merge("#{@api_endpoint.path}/#{@api_version}/#{path}")
 
-      params = options.slice(:label_selector, :field_selector, :resource_version)
-      if params.any?
-        uri.query = URI.encode_www_form(params.map { |k, v| [k.to_s.camelize(:lower), v] })
-      end
+      params = {}
+      WATCH_ARGUMENTS.each { |k, v| params[k] = options[v] if options[v] }
+      uri.query = URI.encode_www_form(params) if params.any?
 
       Kubeclient::Common::WatchStream.new(uri, http_options(uri))
     end
@@ -177,15 +256,13 @@ module Kubeclient
     #   :namespace - the namespace of the entity.
     #   :label_selector - a selector to restrict the list of returned objects by their labels.
     #   :field_selector - a selector to restrict the list of returned objects by their fields.
-    def get_entities(entity_type, klass, options = {})
+    def get_entities(entity_type, klass, resource_name, options = {})
       params = {}
-      [:label_selector, :field_selector].each do |p|
-        params[p.to_s.camelize(:lower)] = options[p] if options[p]
-      end
+      SEARCH_ARGUMENTS.each { |k, v| params[k] = options[v] if options[v] }
 
       ns_prefix = build_namespace_prefix(options[:namespace])
       response = handle_exception do
-        rest_client[ns_prefix + resource_name(entity_type)]
+        rest_client[ns_prefix + resource_name]
         .get({ 'params' => params }.merge(@headers))
       end
 
@@ -203,25 +280,25 @@ module Kubeclient
       Kubeclient::Common::EntityList.new(entity_type, resource_version, collection)
     end
 
-    def get_entity(entity_type, klass, name, namespace = nil)
+    def get_entity(klass, resource_name, name, namespace = nil)
       ns_prefix = build_namespace_prefix(namespace)
       response = handle_exception do
-        rest_client[ns_prefix + resource_name(entity_type) + "/#{name}"]
+        rest_client[ns_prefix + resource_name + "/#{name}"]
         .get(@headers)
       end
       result = JSON.parse(response)
       new_entity(result, klass)
     end
 
-    def delete_entity(entity_type, name, namespace = nil)
+    def delete_entity(resource_name, name, namespace = nil)
       ns_prefix = build_namespace_prefix(namespace)
       handle_exception do
-        rest_client[ns_prefix + resource_name(entity_type) + "/#{name}"]
+        rest_client[ns_prefix + resource_name + "/#{name}"]
           .delete(@headers)
       end
     end
 
-    def create_entity(entity_type, entity_config, klass)
+    def create_entity(entity_type, resource_name, entity_config, klass)
       # Duplicate the entity_config to a hash so that when we assign
       # kind and apiVersion, this does not mutate original entity_config obj.
       hash = entity_config.to_hash
@@ -234,36 +311,36 @@ module Kubeclient
       # TODO: #2 solution for
       # https://github.com/kubernetes/kubernetes/issues/8115
       if entity_type.eql? 'Endpoint'
-        hash[:kind] = resource_name(entity_type).capitalize
+        hash[:kind] = 'Endpoints'
       else
         hash[:kind] = entity_type
       end
-      hash[:apiVersion] = @api_version
-      @headers['Content-Type'] = 'application/json'
+      hash[:apiVersion] = @api_group + @api_version
       response = handle_exception do
-        rest_client[ns_prefix + resource_name(entity_type)]
-        .post(hash.to_json, @headers)
+        rest_client[ns_prefix + resource_name]
+        .post(hash.to_json, { 'Content-Type' => 'application/json' }.merge(@headers))
       end
       result = JSON.parse(response)
       new_entity(result, klass)
     end
 
-    def update_entity(entity_type, entity_config)
+    def update_entity(resource_name, entity_config)
       name      = entity_config[:metadata][:name]
       ns_prefix = build_namespace_prefix(entity_config[:metadata][:namespace])
-      @headers['Content-Type'] = 'application/json'
       handle_exception do
-        rest_client[ns_prefix + resource_name(entity_type) + "/#{name}"]
-          .put(entity_config.to_h.to_json, @headers)
+        rest_client[ns_prefix + resource_name + "/#{name}"]
+          .put(entity_config.to_h.to_json, { 'Content-Type' => 'application/json' }.merge(@headers))
       end
     end
 
-    def patch_entity(entity_type, name, patch, namespace = nil)
+    def patch_entity(resource_name, name, patch, namespace = nil)
       ns_prefix = build_namespace_prefix(namespace)
-      @headers['Content-Type'] = 'application/strategic-merge-patch+json'
       handle_exception do
-        rest_client[ns_prefix + resource_name(entity_type) + "/#{name}"]
-          .patch(patch.to_json, @headers)
+        rest_client[ns_prefix + resource_name + "/#{name}"]
+          .patch(
+            patch.to_json,
+            { 'Content-Type' => 'application/strategic-merge-patch+json' }.merge(@headers)
+          )
       end
     end
 
@@ -271,14 +348,17 @@ module Kubeclient
       klass.new(hash)
     end
 
-    def retrieve_all_entities(entity_types)
-      entity_types.each_with_object({}) do |(_, entity_type), result_hash|
+    def all_entities
+      discover unless @discovered
+      @entities.values.each_with_object({}) do |entity, result_hash|
         # method call for get each entities
         # build hash of entity name to array of the entities
-        entity_name = ClientMixin.pluralize_entity entity_type.underscore
-        method_name = "get_#{entity_name}"
-        key_name = entity_type.underscore
-        result_hash[key_name] = send(method_name)
+        method_name = "get_#{entity.method_names[1]}"
+        begin
+          result_hash[entity.method_names[0]] = send(method_name)
+        rescue KubeException
+          next # do not fail due to resources not supporting get
+        end
       end
     end
 
@@ -310,7 +390,12 @@ module Kubeclient
     end
 
     def proxy_url(kind, name, port, namespace = '')
-      entity_name_plural = ClientMixin.pluralize_entity(kind.to_s)
+      discover unless @discovered
+      entity_name_plural = if %w(services pods nodes).include?(kind.to_s)
+                             kind.to_s
+                           else
+                             @entities[kind.to_s].resource_name
+                           end
       ns_prefix = build_namespace_prefix(namespace)
       # TODO: Change this once services supports the new scheme
       if entity_name_plural == 'pods'
@@ -320,19 +405,24 @@ module Kubeclient
       end
     end
 
-    def resource_name(entity_type)
-      ClientMixin.pluralize_entity entity_type.downcase
+    def process_template(template)
+      ns_prefix = build_namespace_prefix(template[:metadata][:namespace])
+      response = handle_exception do
+        rest_client[ns_prefix + 'processedtemplates']
+        .post(template.to_h.to_json, { 'Content-Type' => 'application/json' }.merge(@headers))
+      end
+      JSON.parse(response)
     end
 
     def api_valid?
       result = api
-      result.is_a?(Hash) && (result['versions'] || []).include?(@api_version)
+      result.is_a?(Hash) && (result['versions'] || []).any? do |group|
+        @api_group.empty? ? group.include?(@api_version) : group['version'] == (@api_version)
+      end
     end
 
     def api
-      response = handle_exception do
-        create_rest_client.get(@headers)
-      end
+      response = handle_exception { create_rest_client.get(@headers) }
       JSON.parse(response)
     end