kubeclient 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cef89055e5f58a17421b6a66f2ad2f3d099a2f76
-  data.tar.gz: 01dcd7211472e9cf10df4ce73ea4eef569c24481
+  metadata.gz: 84f24ef09e48aade18e1be3bf794cc1b207a9bb0
+  data.tar.gz: cead2099decd0352e11904a082cc6b2130e2d053
 SHA512:
-  metadata.gz: fff797cb134a26fd50e3265b1ba303fb5b22d7d02086b1c20c292e8277923f5fe0d3e74a824767bf2315a9644dc46b19da31929e5c04e866e9929b1b0f4d203d
-  data.tar.gz: c5c57ca8ffa4da1ca041053ba43191716caf17e2aa7307559c3406c3abacc85dfaf07102e0368adf8dbf8558e6bbd6177e474db52f572b259b879f10bf00f94c
+  metadata.gz: 47ebfefbac872d301808cec92cd9a0869677844ba693269453150280e4155eee03560ede2e569c3c866a17f4f1293739e586b8653e9926ec981e4d0ec3dc80a4
+  data.tar.gz: d47f3d587234753a1e47c63807364221a9980f4f960b2ccd84486266dc770a5fe0e9d6dd7b127c6b7e6959a6b096af6b62e20c303a2f19a277b5c290f3c2eaac

data/README.md

@@ -6,7 +6,7 @@
 [![Dependency Status](https://gemnasium.com/abonas/kubeclient.svg)](https://gemnasium.com/abonas/kubeclient)
 
 A Ruby client for Kubernetes REST api.
-The client supports GET, POST, PUT, DELETE on nodes, pods, secrets, services, replication controllers, namespaces, resource quotas, limit ranges and endpoints.
+The client supports GET, POST, PUT, DELETE on nodes, pods, secrets, services, replication controllers, namespaces, resource quotas, limit ranges, endpoints, persistent volumes and persistent volume claims.
 The client currently supports Kubernetes REST api version v1beta3.
 
 ## Installation
@@ -72,7 +72,7 @@ of the following:
 
 ```ruby
 auth_options = {
-  user: 'username',
+  username: 'username',
   password: 'password'
 }
 client = Kubeclient::Client.new 'https://localhost:8443/api/' , 'v1beta3',
@@ -118,7 +118,7 @@ client = Kubeclient::Client.new 'https://localhost:8443/api/' , 'v1beta3',
 ## Examples:
 
 #### Get all instances of a specific entity type
-Such as: `get_pods`, `get_secrets`, `get_services`, `get_nodes`, `get_replication_controllers`, `get_resource_quotas`, `get_limit_ranges`
+Such as: `get_pods`, `get_secrets`, `get_services`, `get_nodes`, `get_replication_controllers`, `get_resource_quotas`, `get_limit_ranges`, `get_persistent_volumes`, `get_persistent_volume_claims`
 
 ```ruby
 pods = client.get_pods
@@ -134,7 +134,7 @@ pods = client.get_pods(label_selector: 'name=redis-master,app=redis')
 ```
 
 #### Get a specific instance of an entity (by name)
-Such as: `get_service "service name"` , `get_pod "pod name"` , `get_replication_controller "rc name"`, `get_secret "secret name"`, `get_resource_quota "resource quota name"`, `get_limit_range "limit range name"`
+Such as: `get_service "service name"` , `get_pod "pod name"` , `get_replication_controller "rc name"`, `get_secret "secret name"`, `get_resource_quota "resource quota name"`, `get_limit_range "limit range name"` , `get_persistent_volume "persistent volume name"` , `get_persistent_volume_claim "persistent volume claim name"`
 
 The GET request should include the namespace name, except for nodes and namespaces entities.
 
@@ -159,7 +159,7 @@ client.delete_service "redis-service"
 ```
 
 #### Create an entity
-For example: `create_pod pod_object`, `create_replication_controller rc_obj`, `create_secret secret_object`, `create_resource_quota resource_quota_object`, `create_limit_range limit_range_object`
+For example: `create_pod pod_object`, `create_replication_controller rc_obj`, `create_secret secret_object`, `create_resource_quota resource_quota_object`, `create_limit_range limit_range_object`, `create_persistent_volume persistent_volume_object`, `create_persistent_volume_claim persistent_volume_claim_object`
 
 Input parameter - object of type `Service`, `Pod`, `ReplicationController`.
 
@@ -177,7 +177,7 @@ client.create_service service`
 ```
 
 #### Update an entity
-For example: `update_pod`, `update_service`, `update_replication_controller`, `update_secret`, `update_resource_quota`, `update_limit_range`
+For example: `update_pod`, `update_service`, `update_replication_controller`, `update_secret`, `update_resource_quota`, `update_limit_range`, `update_persistent_volume`, `update_persistent_volume_claim`
 
 Input parameter - object of type `Pod`, `Service`, `ReplicationController` etc.
 
@@ -188,7 +188,7 @@ client.update_service service1
 ```
 
 #### Get all entities of all types : all_entities
-Returns a hash with 10 keys (node, secret, service, pod, replication_controller, namespace, resource_quota, limit_range, endpoint and event). Each key points to an EntityList of same type.
+Returns a hash with 12 keys (node, secret, service, pod, replication_controller, namespace, resource_quota, limit_range, endpoint, event, persistent_volume and persistent_volume_claim). Each key points to an EntityList of same type.
 
 This method is a convenience method instead of calling each entity's get method separately.
 
@@ -212,6 +212,23 @@ It is possible to interrupt the watcher from another thread with:
 watcher.finish
 ```
 
+#### Get a proxy URL
+You can get a complete URL for connecting a kubernetes entity via the proxy.
+
+```ruby
+client.proxy_url('service', 'srvname', 'srvportname', 'ns')
+ => "https://localhost.localdomain:8443/api/v1/proxy/namespaces/ns/services/srvname:srvportname"
+```
+
+Note the third parameter, port, is a port name for services and an integer for pods:
+
+```ruby
+client.proxy_url('pod', 'podname', 5001, 'ns')
+ => "https://localhost.localdomain:8443/api/v1/namespaces/ns/pods/podname:5001/proxy"
+```
+
+
+
 ## Contributing
 
 1. Fork it ( https://github.com/[my-github-username]/kubeclient/fork )

data/lib/kubeclient.rb

@@ -10,15 +10,16 @@ require 'kubeclient/common'
 
 module Kubeclient
   # Kubernetes Client
-  class Client < Common::Client
-    attr_reader :api_endpoint
+  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).map do |et|
+                      Namespace Secret ResourceQuota LimitRange PersistentVolume
+                      PersistentVolumeClaim).map do |et|
       clazz = Class.new(RecursiveOpenStruct) do
         def initialize(hash = nil, args = {})
           args.merge!(recurse_over_arrays: true)
@@ -28,6 +29,8 @@ module Kubeclient
       [Kubeclient.const_set(et, clazz), et]
     end
 
+    ClientMixin.define_entity_methods(ENTITY_TYPES)
+
     def initialize(uri,
                    version = 'v1beta3',
                    ssl_options: {
@@ -36,43 +39,18 @@ module Kubeclient
                      ca_file: nil,
                      verify_ssl: OpenSSL::SSL::VERIFY_PEER
                    },
-                   auth_options: {}
+                   auth_options: {
+                     username:          nil,
+                     password:          nil,
+                     bearer_token:      nil,
+                     bearer_token_file: nil
+                   }
                   )
-
-      fail ArgumentError, 'Missing uri' if uri.nil?
-
-      validate_auth_options(auth_options)
-
-      handle_uri(uri, '/api')
-      @api_version = version
-      @headers = {}
-      @ssl_options = ssl_options
-
-      if auth_options[:user]
-        @basic_auth_user = auth_options[:user]
-        @basic_auth_password = auth_options[:password]
-      elsif auth_options[:bearer_token]
-        bearer_token(auth_options[:bearer_token])
-      elsif auth_options[:bearer_token_file]
-        validate_bearer_token_file(auth_options[:bearer_token_file])
-        bearer_token(File.read(auth_options[:bearer_token_file]))
-      end
+      initialize_client(uri, '/api', version, ssl_options: ssl_options, auth_options: auth_options)
     end
 
     def all_entities
       retrieve_all_entities(ENTITY_TYPES)
     end
-
-    define_entity_methods(ENTITY_TYPES)
-
-    private
-
-    def validate_bearer_token_file(bearer_token_file)
-      msg = "Token file #{bearer_token_file} does not exist"
-      fail ArgumentError, msg unless File.file?(bearer_token_file)
-
-      msg = "Cannot read token file #{bearer_token_file}"
-      fail ArgumentError, msg unless File.readable?(bearer_token_file)
-    end
   end
 end

data/lib/kubeclient/common.rb

@@ -1,244 +1,299 @@
 require 'json'
 require 'rest-client'
 module Kubeclient
-  module Common
-    # Common methods
-    class Client
-      def handle_exception
-        yield
-      rescue RestClient::Exception => e
-        begin
-          json_error_msg = JSON.parse(e.response || '') || {}
-        rescue JSON::ParserError
-          json_error_msg = {}
-        end
-        err_message = json_error_msg['message'] || e.message
-        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? '/'
+  # Common methods
+  module ClientMixin
+    attr_reader :api_endpoint
+    attr_reader :ssl_options
+    attr_reader :auth_options
+    attr_reader :headers
+
+    def initialize_client(
+      uri,
+      path,
+      version = nil,
+      ssl_options: {
+        client_cert: nil,
+        client_key: nil,
+        ca_file: nil,
+        verify_ssl: OpenSSL::SSL::VERIFY_PEER
+      },
+      auth_options: {
+        username: nil,
+        password: nil,
+        bearer_token: nil,
+        bearer_token_file: nil
+      }
+    )
+      validate_auth_options(auth_options)
+      handle_uri(uri, path)
+
+      @api_version = version
+      @headers = {}
+      @ssl_options = ssl_options
+      @auth_options = auth_options
+
+      if auth_options[:bearer_token]
+        @headers[:Authorization] = "Bearer #{@auth_options[:bearer_token]}"
+      elsif auth_options[:bearer_token_file]
+        validate_bearer_token_file
+        @headers[:Authorization] = "Bearer #{File.read(@auth_options[:bearer_token_file])}"
       end
+    end
 
-      def build_namespace_prefix(namespace)
-        namespace.to_s.empty? ? '' : "namespaces/#{namespace}/"
+    def handle_exception
+      yield
+    rescue RestClient::Exception => e
+      begin
+        json_error_msg = JSON.parse(e.response || '') || {}
+      rescue JSON::ParserError
+        json_error_msg = {}
       end
+      err_message = json_error_msg['message'] || e.message
+      raise KubeException.new(e.http_code, err_message)
+    end
 
-      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 handle_uri(uri, path)
+      fail ArgumentError, 'Missing uri' if uri.nil?
+      @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
 
-          # 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
+    def build_namespace_prefix(namespace)
+      namespace.to_s.empty? ? '' : "namespaces/#{namespace}/"
+    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
+    public
 
-          # 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)
-          end
+    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)
 
-          define_method("delete_#{entity_name}") do |name, namespace = nil|
-            delete_entity(entity_type, name, namespace)
-          end
+        # 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
 
-          define_method("create_#{entity_name}") do |entity_config|
-            create_entity(entity_type, entity_config, klass)
-          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
 
-          define_method("update_#{entity_name}") do |entity_config|
-            update_entity(entity_type, entity_config)
-          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)
         end
-      end
 
-      def self.pluralize_entity(entity_name)
-        return entity_name + 's' if entity_name.end_with? 'quota'
-        entity_name.pluralize
-      end
+        define_method("delete_#{entity_name}") do |name, namespace = nil|
+          delete_entity(entity_type, name, namespace)
+        end
 
-      def create_rest_client(path = nil)
-        path ||= @api_endpoint.path
-        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],
-          user: @basic_auth_user,
-          password: @basic_auth_password
-        }
-        RestClient::Resource.new(@api_endpoint.merge(path).to_s, options)
-      end
+        define_method("create_#{entity_name}") do |entity_config|
+          create_entity(entity_type, entity_config, klass)
+        end
 
-      def rest_client
-        @rest_client ||= begin
-          create_rest_client("#{@api_endpoint.path}/#{@api_version}")
+        define_method("update_#{entity_name}") do |entity_config|
+          update_entity(entity_type, entity_config)
         end
       end
+    end
 
-      def watch_entities(entity_type, resource_version = nil)
-        resource = resource_name(entity_type.to_s)
-
-        uri = @api_endpoint
-              .merge("#{@api_endpoint.path}/#{@api_version}/watch/#{resource}")
+    def self.pluralize_entity(entity_name)
+      return entity_name + 's' if entity_name.end_with? 'quota'
+      entity_name.pluralize
+    end
 
-        unless resource_version.nil?
-          uri.query = URI.encode_www_form('resourceVersion' => resource_version)
-        end
+    def create_rest_client(path = nil)
+      path ||= @api_endpoint.path
+      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],
+        user: @auth_options[:username],
+        password: @auth_options[:password]
+      }
+      RestClient::Resource.new(@api_endpoint.merge(path).to_s, options)
+    end
 
-        options = {
-          use_ssl: uri.scheme == 'https',
-          ca_file: @ssl_options[:ca_file],
-          # ruby Net::HTTP uses verify_mode instead of verify_ssl
-          # http://ruby-doc.org/stdlib-1.9.3/libdoc/net/http/rdoc/Net/HTTP.html
-          verify_mode: @ssl_options[:verify_ssl],
-          cert: @ssl_options[:client_cert],
-          key: @ssl_options[:client_key],
-          basic_auth_user: @basic_auth_user,
-          basic_auth_password: @basic_auth_password,
-          headers: @headers
-        }
-
-        WatchStream.new(uri, options)
-      end
-
-      def get_entities(entity_type, klass, options)
-        params = {}
-        if options[:label_selector]
-          params['params'] = { labelSelector: options[:label_selector] }
-        end
+    def rest_client
+      @rest_client ||= begin
+        create_rest_client("#{@api_endpoint.path}/#{@api_version}")
+      end
+    end
 
-        # TODO: namespace support?
-        response = handle_exception do
-          rest_client[resource_name(entity_type)]
-          .get(params.merge(@headers))
-        end
+    def watch_entities(entity_type, resource_version = nil)
+      resource = resource_name(entity_type.to_s)
 
-        result = JSON.parse(response)
+      uri = @api_endpoint
+            .merge("#{@api_endpoint.path}/#{@api_version}/watch/#{resource}")
 
-        resource_version = result.fetch('resourceVersion', nil)
-        if resource_version.nil?
-          resource_version =
-              result.fetch('metadata', {}).fetch('resourceVersion', nil)
-        end
+      unless resource_version.nil?
+        uri.query = URI.encode_www_form('resourceVersion' => resource_version)
+      end
 
-        collection = result['items'].map { |item| new_entity(item, klass) }
+      options = {
+        use_ssl: uri.scheme == 'https',
+        ca_file: @ssl_options[:ca_file],
+        # ruby Net::HTTP uses verify_mode instead of verify_ssl
+        # http://ruby-doc.org/stdlib-1.9.3/libdoc/net/http/rdoc/Net/HTTP.html
+        verify_mode: @ssl_options[:verify_ssl],
+        cert: @ssl_options[:client_cert],
+        key: @ssl_options[:client_key],
+        basic_auth_user: @auth_options[:username],
+        basic_auth_password: @auth_options[:password],
+        headers: @headers
+      }
+
+      Kubeclient::Common::WatchStream.new(uri, options)
+    end
 
-        EntityList.new(entity_type, resource_version, collection)
+    def get_entities(entity_type, klass, options)
+      params = {}
+      if options[:label_selector]
+        params['params'] = { labelSelector: options[:label_selector] }
       end
 
-      def get_entity(entity_type, klass, name, namespace = nil)
-        ns_prefix = build_namespace_prefix(namespace)
-        response = handle_exception do
-          rest_client[ns_prefix + resource_name(entity_type) + "/#{name}"]
-          .get(@headers)
-        end
-        result = JSON.parse(response)
-        new_entity(result, klass)
+      # TODO: namespace support?
+      response = handle_exception do
+        rest_client[resource_name(entity_type)]
+        .get(params.merge(@headers))
       end
 
-      def delete_entity(entity_type, name, namespace = nil)
-        ns_prefix = build_namespace_prefix(namespace)
-        handle_exception do
-          rest_client[ns_prefix + resource_name(entity_type) + "/#{name}"]
-            .delete(@headers)
-        end
+      result = JSON.parse(response)
+
+      resource_version = result.fetch('resourceVersion', nil)
+      if resource_version.nil?
+        resource_version =
+            result.fetch('metadata', {}).fetch('resourceVersion', nil)
       end
 
-      def create_entity(entity_type, entity_config, klass)
-        # to_hash should be called because of issue #9 in recursive open
-        # struct
-        hash = entity_config.to_hash
+      collection = result['items'].map { |item| new_entity(item, klass) }
 
-        ns_prefix = build_namespace_prefix(entity_config.metadata.namespace)
+      Kubeclient::Common::EntityList.new(entity_type, resource_version, collection)
+    end
 
-        # TODO: temporary solution to add "kind" and apiVersion to request
-        # until this issue is solved
-        # https://github.com/GoogleCloudPlatform/kubernetes/issues/6439
-        hash['kind'] = entity_type
-        hash['apiVersion'] = @api_version
-        response = handle_exception do
-          rest_client[ns_prefix + resource_name(entity_type)]
-          .post(hash.to_json, @headers)
-        end
-        result = JSON.parse(response)
-        new_entity(result, klass)
-      end
-
-      def update_entity(entity_type, entity_config)
-        name = entity_config.metadata.name
-        # to_hash should be called because of issue #9 in recursive open
-        # struct
-        hash = entity_config.to_hash
-        ns_prefix = build_namespace_prefix(entity_config.metadata.namespace)
-        handle_exception do
-          rest_client[ns_prefix + resource_name(entity_type) + "/#{name}"]
-            .put(hash.to_json, @headers)
-        end
+    def get_entity(entity_type, klass, name, namespace = nil)
+      ns_prefix = build_namespace_prefix(namespace)
+      response = handle_exception do
+        rest_client[ns_prefix + resource_name(entity_type) + "/#{name}"]
+        .get(@headers)
       end
+      result = JSON.parse(response)
+      new_entity(result, klass)
+    end
 
-      def new_entity(hash, klass)
-        klass.new(hash)
+    def delete_entity(entity_type, name, namespace = nil)
+      ns_prefix = build_namespace_prefix(namespace)
+      handle_exception do
+        rest_client[ns_prefix + resource_name(entity_type) + "/#{name}"]
+          .delete(@headers)
       end
+    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
-          entity_name = self.class.pluralize_entity entity_type.underscore
-          method_name = "get_#{entity_name}"
-          key_name = entity_type.underscore
-          result_hash[key_name] = send(method_name)
-        end
+    def create_entity(entity_type, entity_config, klass)
+      # to_hash should be called because of issue #9 in recursive open
+      # struct
+      hash = entity_config.to_hash
+
+      ns_prefix = build_namespace_prefix(entity_config.metadata['table'][:namespace])
+
+      # TODO: temporary solution to add "kind" and apiVersion to request
+      # until this issue is solved
+      # https://github.com/GoogleCloudPlatform/kubernetes/issues/6439
+      hash['kind'] = entity_type
+      hash['apiVersion'] = @api_version
+      response = handle_exception do
+        rest_client[ns_prefix + resource_name(entity_type)]
+        .post(hash.to_json, @headers)
       end
+      result = JSON.parse(response)
+      new_entity(result, klass)
+    end
 
-      def resource_name(entity_type)
-        self.class.pluralize_entity entity_type.downcase
+    def update_entity(entity_type, entity_config)
+      name = entity_config.metadata.name
+      # to_hash should be called because of issue #9 in recursive open
+      # struct
+      hash = entity_config.to_hash
+      ns_prefix = build_namespace_prefix(entity_config.metadata['table'][:namespace])
+      handle_exception do
+        rest_client[ns_prefix + resource_name(entity_type) + "/#{name}"]
+          .put(hash.to_json, @headers)
       end
+    end
 
-      def api_valid?
-        result = api
-        result.is_a?(Hash) && (result['versions'] || []).include?(@api_version)
+    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
+        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)
       end
+    end
 
-      def api
-        response = handle_exception do
-          create_rest_client.get(@headers)
-        end
-        JSON.parse(response)
+    def proxy_url(kind, name, port, namespace = '')
+      entity_name_plural = ClientMixin.pluralize_entity(kind.to_s)
+      ns_prefix = build_namespace_prefix(namespace)
+      # TODO: Change this once services supports the new scheme
+      if entity_name_plural == 'pods'
+        rest_client["#{ns_prefix}#{entity_name_plural}/#{name}:#{port}/proxy"].url
+      else
+        rest_client["proxy/#{ns_prefix}#{entity_name_plural}/#{name}:#{port}"].url
       end
+    end
+
+    def resource_name(entity_type)
+      ClientMixin.pluralize_entity entity_type.downcase
+    end
 
-      private
+    def api_valid?
+      result = api
+      result.is_a?(Hash) && (result['versions'] || []).include?(@api_version)
+    end
 
-      def bearer_token(bearer_token)
-        @headers ||= {}
-        @headers[:Authorization] = "Bearer #{bearer_token}"
+    def api
+      response = handle_exception do
+        create_rest_client.get(@headers)
       end
+      JSON.parse(response)
+    end
 
-      def validate_auth_options(opts)
-        exclusive_keys = [:bearer_token, :bearer_token_file, :user]
+    private
 
-        return if exclusive_keys.none? { |s| opts.key?(s) }
+    def bearer_token(bearer_token)
+      @headers ||= {}
+      @headers[:Authorization] = "Bearer #{bearer_token}"
+    end
 
-        msg = 'Invalid auth options: specify only one of user/password,' \
-            ' bearer_token or bearer_token_file'
-        fail ArgumentError, msg unless exclusive_keys.one? { |s| opts.key?(s)  }
+    def validate_auth_options(opts)
+      # maintain backward compatibility:
+      opts[:username] = opts[:user] if opts[:user]
 
-        msg = 'Basic auth requires both user & password'
-        fail ArgumentError, msg if opts.key?(:user) && !opts.key?(:password)
+      if [:bearer_token, :bearer_token_file, :username].count { |key| opts[key] } > 1
+        fail(ArgumentError, 'Invalid auth options: specify only one of username/password,' \
+             ' bearer_token or bearer_token_file')
+      elsif [:username, :password].count { |key| opts[key] } == 1
+        fail(ArgumentError, 'Basic auth requires both username & password')
       end
     end
+
+    def validate_bearer_token_file
+      msg = "Token file #{@auth_options[:bearer_token_file]} does not exist"
+      fail ArgumentError, msg unless File.file?(@auth_options[:bearer_token_file])
+
+      msg = "Cannot read token file #{@auth_options[:bearer_token_file]}"
+      fail ArgumentError, msg unless File.readable?(@auth_options[:bearer_token_file])
+    end
   end
 end

data/lib/kubeclient/version.rb

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

data/test/json/persistent_volume.json

@@ -0,0 +1,37 @@
+{
+  "kind": "PersistentVolume",
+  "apiVersion": "v1",
+  "metadata": {
+    "name": "pv0001",
+    "selfLink": "/api/v1/persistentvolumes/pv0001",
+    "uid": "c83eece1-4b38-11e5-8d27-28d2447dcefe",
+    "resourceVersion": "1585",
+    "creationTimestamp": "2015-08-25T14:51:35Z",
+    "labels": {
+      "type": "local"
+    }
+  },
+  "spec": {
+    "capacity": {
+      "storage": "10Gi"
+    },
+    "hostPath": {
+      "path": "/tmp/data01"
+    },
+    "accessModes": [
+      "ReadWriteOnce"
+    ],
+    "claimRef": {
+      "kind": "PersistentVolumeClaim",
+      "namespace": "default",
+      "name": "myclaim-1",
+      "uid": "d47384a3-4b38-11e5-8d27-28d2447dcefe",
+      "apiVersion": "v1",
+      "resourceVersion": "1582"
+    },
+    "persistentVolumeReclaimPolicy": "Retain"
+  },
+  "status": {
+    "phase": "Bound"
+  }
+}

data/test/json/persistent_volume_claim.json

@@ -0,0 +1,32 @@
+{
+  "kind": "PersistentVolumeClaim",
+  "apiVersion": "v1",
+  "metadata": {
+    "name": "myclaim-1",
+    "namespace": "default",
+    "selfLink": "/api/v1/namespaces/default/persistentvolumeclaims/myclaim-1",
+    "uid": "d47384a3-4b38-11e5-8d27-28d2447dcefe",
+    "resourceVersion": "1584",
+    "creationTimestamp": "2015-08-25T14:51:55Z"
+  },
+  "spec": {
+    "accessModes": [
+      "ReadWriteOnce"
+    ],
+    "resources": {
+      "requests": {
+        "storage": "3Gi"
+      }
+    },
+    "volumeName": "pv0001"
+  },
+  "status": {
+    "phase": "Bound",
+    "accessModes": [
+      "ReadWriteOnce"
+    ],
+    "capacity": {
+      "storage": "10Gi"
+    }
+  }
+}

data/test/json/persistent_volume_claim_list.json

@@ -0,0 +1,40 @@
+{
+  "kind": "PersistentVolumeClaimList",
+  "apiVersion": "v1",
+  "metadata": {
+    "selfLink": "/api/v1/persistentvolumeclaims",
+    "resourceVersion": "3188"
+  },
+  "items": [
+    {
+      "metadata": {
+        "name": "myclaim-1",
+        "namespace": "default",
+        "selfLink": "/api/v1/namespaces/default/persistentvolumeclaims/myclaim-1",
+        "uid": "d47384a3-4b38-11e5-8d27-28d2447dcefe",
+        "resourceVersion": "1584",
+        "creationTimestamp": "2015-08-25T14:51:55Z"
+      },
+      "spec": {
+        "accessModes": [
+          "ReadWriteOnce"
+        ],
+        "resources": {
+          "requests": {
+            "storage": "3Gi"
+          }
+        },
+        "volumeName": "pv0001"
+      },
+      "status": {
+        "phase": "Bound",
+        "accessModes": [
+          "ReadWriteOnce"
+        ],
+        "capacity": {
+          "storage": "10Gi"
+        }
+      }
+    }
+  ]
+}

data/test/json/persistent_volume_list.json

@@ -0,0 +1,45 @@
+{
+  "kind": "PersistentVolumeList",
+  "apiVersion": "v1",
+  "metadata": {
+    "selfLink": "/api/v1/persistentvolumes",
+    "resourceVersion": "2999"
+  },
+  "items": [
+    {
+      "metadata": {
+        "name": "pv0001",
+        "selfLink": "/api/v1/persistentvolumes/pv0001",
+        "uid": "c83eece1-4b38-11e5-8d27-28d2447dcefe",
+        "resourceVersion": "1585",
+        "creationTimestamp": "2015-08-25T14:51:35Z",
+        "labels": {
+          "type": "local"
+        }
+      },
+      "spec": {
+        "capacity": {
+          "storage": "10Gi"
+        },
+        "hostPath": {
+          "path": "/tmp/data01"
+        },
+        "accessModes": [
+          "ReadWriteOnce"
+        ],
+        "claimRef": {
+          "kind": "PersistentVolumeClaim",
+          "namespace": "default",
+          "name": "myclaim-1",
+          "uid": "d47384a3-4b38-11e5-8d27-28d2447dcefe",
+          "apiVersion": "v1",
+          "resourceVersion": "1582"
+        },
+        "persistentVolumeReclaimPolicy": "Retain"
+      },
+      "status": {
+        "phase": "Bound"
+      }
+    }
+  ]
+}

data/test/test_kubeclient.rb

@@ -227,9 +227,17 @@ class KubeClientTest < MiniTest::Test
       .to_return(body: open_test_json_file('limit_range_list.json'),
                  status: 200)
 
+    stub_request(:get, %r{/persistentvolumes})
+      .to_return(body: open_test_json_file('persistent_volume_list.json'),
+                 status: 200)
+
+    stub_request(:get, %r{/persistentvolumeclaims})
+      .to_return(body: open_test_json_file('persistent_volume_claim_list.json'),
+                 status: 200)
+
     client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1beta3'
     result = client.all_entities
-    assert_equal(10, result.keys.size)
+    assert_equal(12, result.keys.size)
     assert_instance_of(Kubeclient::Common::EntityList, result['node'])
     assert_instance_of(Kubeclient::Common::EntityList, result['service'])
     assert_instance_of(Kubeclient::Common::EntityList,
@@ -246,6 +254,8 @@ class KubeClientTest < MiniTest::Test
     assert_instance_of(Kubeclient::Secret, result['secret'][0])
     assert_instance_of(Kubeclient::ResourceQuota, result['resource_quota'][0])
     assert_instance_of(Kubeclient::LimitRange, result['limit_range'][0])
+    assert_instance_of(Kubeclient::PersistentVolume, result['persistent_volume'][0])
+    assert_instance_of(Kubeclient::PersistentVolumeClaim, result['persistent_volume_claim'][0])
   end
 
   def test_api_bearer_token_with_params_success
@@ -305,6 +315,26 @@ class KubeClientTest < MiniTest::Test
       .to_return(body: open_test_json_file('pod_list_b3.json'),
                  status: 200)
 
+    client = Kubeclient::Client.new 'http://localhost:8080/api/',
+                                    auth_options: {
+                                      username: 'username',
+                                      password: 'password'
+                                    }
+
+    pods = client.get_pods
+
+    assert_equal('Pod', pods.kind)
+    assert_equal(1, pods.size)
+    assert_requested(:get,
+                     'http://username:password@localhost:8080/api/v1beta3/pods',
+                     times: 1)
+  end
+
+  def test_api_basic_auth_back_comp_success
+    stub_request(:get, 'http://username:password@localhost:8080/api/v1beta3/pods')
+      .to_return(body: open_test_json_file('pod_list_b3.json'),
+                 status: 200)
+
     client = Kubeclient::Client.new 'http://localhost:8080/api/',
                                     auth_options: {
                                       user: 'username',
@@ -328,7 +358,7 @@ class KubeClientTest < MiniTest::Test
 
     client = Kubeclient::Client.new 'http://localhost:8080/api/',
                                     auth_options: {
-                                      user: 'username',
+                                      username: 'username',
                                       password: 'password'
                                     }
 
@@ -340,8 +370,19 @@ class KubeClientTest < MiniTest::Test
                      times: 1)
   end
 
+  def test_init_username_no_password
+    expected_msg = 'Basic auth requires both username & password'
+    exception = assert_raises(ArgumentError) do
+      Kubeclient::Client.new 'http://localhost:8080',
+                             auth_options: {
+                               username: 'username'
+                             }
+    end
+    assert_equal expected_msg, exception.message
+  end
+
   def test_init_user_no_password
-    expected_msg = 'Basic auth requires both user & password'
+    expected_msg = 'Basic auth requires both username & password'
     exception = assert_raises(ArgumentError) do
       Kubeclient::Client.new 'http://localhost:8080',
                              auth_options: {
@@ -351,13 +392,26 @@ class KubeClientTest < MiniTest::Test
     assert_equal expected_msg, exception.message
   end
 
+  def test_init_username_and_bearer_token
+    expected_msg = 'Invalid auth options: specify only one of username/password,' \
+                   ' bearer_token or bearer_token_file'
+    exception = assert_raises(ArgumentError) do
+      Kubeclient::Client.new 'http://localhost:8080',
+                             auth_options: {
+                               username: 'username',
+                               bearer_token: 'token'
+                             }
+    end
+    assert_equal expected_msg, exception.message
+  end
+
   def test_init_user_and_bearer_token
-    expected_msg = 'Invalid auth options: specify only one of user/password,' \
+    expected_msg = 'Invalid auth options: specify only one of username/password,' \
                    ' bearer_token or bearer_token_file'
     exception = assert_raises(ArgumentError) do
       Kubeclient::Client.new 'http://localhost:8080',
                              auth_options: {
-                               user: 'username',
+                               username: 'username',
                                bearer_token: 'token'
                              }
     end
@@ -365,7 +419,7 @@ class KubeClientTest < MiniTest::Test
   end
 
   def test_bearer_token_and_bearer_token_file
-    expected_msg = 'Invalid auth options: specify only one of user/password,' \
+    expected_msg = 'Invalid auth options: specify only one of username/password,' \
                    ' bearer_token or bearer_token_file'
     exception = assert_raises(ArgumentError) do
       Kubeclient::Client.new 'http://localhost:8080',
@@ -406,6 +460,37 @@ class KubeClientTest < MiniTest::Test
     assert_equal(1, pods.size)
   end
 
+  def test_proxy_url
+    client = Kubeclient::Client.new 'http://host:8080', 'v1'
+    assert_equal('http://host:8080/api/v1/proxy/namespaces/ns/services/srvname:srvportname',
+                 client.proxy_url('service', 'srvname', 'srvportname', 'ns'))
+
+    assert_equal('http://host:8080/api/v1/namespaces/ns/pods/srvname:srvportname/proxy',
+                 client.proxy_url('pods', 'srvname', 'srvportname', 'ns'))
+
+    # Check no namespace provided
+    assert_equal('http://host:8080/api/v1/proxy/nodes/srvname:srvportname',
+                 client.proxy_url('nodes', 'srvname', 'srvportname'))
+
+    # Check integer port
+    assert_equal('http://host:8080/api/v1/proxy/nodes/srvname:5001',
+                 client.proxy_url('nodes', 'srvname', 5001))
+  end
+
+  def test_attr_readers
+    client = Kubeclient::Client.new 'http://localhost:8080/api/',
+                                    ssl_options: {
+                                      client_key: 'secret'
+                                    },
+                                    auth_options: {
+                                      bearer_token: 'token'
+                                    }
+    assert_equal '/api', client.api_endpoint.path
+    assert_equal 'secret', client.ssl_options[:client_key]
+    assert_equal 'token', client.auth_options[:bearer_token]
+    assert_equal 'Bearer token', client.headers[:Authorization]
+  end
+
   private
 
   # dup method creates a shallow copy which is not good in this case

data/test/test_persistent_volume.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+# PersistentVolume tests
+class TestPersistentVolume < MiniTest::Test
+  def test_get_from_json_v3
+    stub_request(:get, %r{/persistentvolumes})
+      .to_return(body: open_test_json_file('persistent_volume.json'),
+                 status: 200)
+
+    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
+    volume = client.get_persistent_volume 'pv0001'
+
+    assert_instance_of(Kubeclient::PersistentVolume, volume)
+    assert_equal('pv0001', volume.metadata.name)
+    assert_equal('10Gi', volume.spec.capacity.storage)
+    assert_equal('/tmp/data01', volume.spec.hostPath.path)
+
+    assert_requested(:get,
+                     'http://localhost:8080/api/v1/persistentvolumes/pv0001',
+                     times: 1)
+  end
+end

data/test/test_persistent_volume_claim.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+# PersistentVolumeClaim tests
+class TestPersistentVolumeClaim < MiniTest::Test
+  def test_get_from_json_v3
+    stub_request(:get, %r{/persistentvolumeclaims})
+      .to_return(body: open_test_json_file('persistent_volume_claim.json'),
+                 status: 200)
+
+    client = Kubeclient::Client.new 'http://localhost:8080/api/', 'v1'
+    claim = client.get_persistent_volume_claim 'myclaim-1', 'default'
+
+    assert_instance_of(Kubeclient::PersistentVolumeClaim, claim)
+    assert_equal('myclaim-1', claim.metadata.name)
+    assert_equal('3Gi', claim.spec.resources.requests.storage)
+    assert_equal('pv0001', claim.spec.volumeName)
+
+    assert_requested(:get,
+                     'http://localhost:8080/api/v1/namespaces/default/persistentvolumeclaims/myclaim-1',
+                     times: 1)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kubeclient
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Alissa Bonas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-23 00:00:00.000000000 Z
+date: 2015-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -172,6 +172,10 @@ files:
 - test/json/namespace_list_b3.json
 - test/json/node_b3.json
 - test/json/node_list_b3.json
+- test/json/persistent_volume.json
+- test/json/persistent_volume_claim.json
+- test/json/persistent_volume_claim_list.json
+- test/json/persistent_volume_list.json
 - test/json/pod_b3.json
 - test/json/pod_list_b3.json
 - test/json/replication_controller_b3.json
@@ -190,6 +194,8 @@ files:
 - test/test_limit_range.rb
 - test/test_namespace.rb
 - test/test_node.rb
+- test/test_persistent_volume.rb
+- test/test_persistent_volume_claim.rb
 - test/test_pod.rb
 - test/test_replication_controller.rb
 - test/test_resource_quota.rb
@@ -217,7 +223,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: A client for Kubernetes REST api
@@ -236,6 +242,10 @@ test_files:
 - test/json/namespace_list_b3.json
 - test/json/node_b3.json
 - test/json/node_list_b3.json
+- test/json/persistent_volume.json
+- test/json/persistent_volume_claim.json
+- test/json/persistent_volume_claim_list.json
+- test/json/persistent_volume_list.json
 - test/json/pod_b3.json
 - test/json/pod_list_b3.json
 - test/json/replication_controller_b3.json
@@ -254,6 +264,8 @@ test_files:
 - test/test_limit_range.rb
 - test/test_namespace.rb
 - test/test_node.rb
+- test/test_persistent_volume.rb
+- test/test_persistent_volume_claim.rb
 - test/test_pod.rb
 - test/test_replication_controller.rb
 - test/test_resource_quota.rb