kubeclient 2.3.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f4032a685c46d5955f63ffcc006171bddc30e09
-  data.tar.gz: 005aee870fc479f06d43d8a38aaf15f938b076dd
+  metadata.gz: 8fce3b9093ea679f3884d8af4728dfc3005a0c36
+  data.tar.gz: 561a92297a3da43106d56ebf7bef5d0e572f0904
 SHA512:
-  metadata.gz: 3ba975b163f88ac63f41cddddbc4e5e59b4ac4272cc4a223e7bfb718145ac92441bdbdaf5c46faf06fc1c506bbda0043a908f0082f823c10618729148ff70d24
-  data.tar.gz: 3a50235a3727a4707a33803b51194791808e5156157a00ba98463617a222f8549eea64c6f88ebed9b578bf08386b23ff52b019411084a571e9fd5a7f702b2995
+  metadata.gz: e250ffc5c7246e29340212a65132496e4aff7aacd88cac3906348bc1b62988104af59ac6c50adc83f036132cbd989d958cdf728afc4679f9aa1b60b4b1e4b5ff
+  data.tar.gz: 4d1f175cf90cbf673f16e55601bb7b86801f5a7fbd6e7ec1507517761e83733b0a45a8c43848caf608f7389e29350ad5b6f3389ec12957f1de613ed45d9d5601

data/.rubocop.yml

@@ -7,6 +7,9 @@ Metrics/AbcSize:
 Metrics/LineLength:
   Max: 100
 Metrics/ParameterLists:
-  Max: 8
+  Max: 5
+  CountKeywordArgs: false
 Metrics/CyclomaticComplexity:
   Max: 8
+Style/FileName:
+  Exclude: [Gemfile*]

data/.travis.yml

@@ -4,9 +4,17 @@ rvm:
   - "2.1"
   - "2.2"
   - "2.3.0"
+gemfile:
+  - Gemfile
+  - Gemfile-rest-client-1.8.rb
 sudo: false
 cache: bundler
 script: bundle exec rake $TASK
 env:
  - TASK=test
  - TASK=rubocop
+matrix:
+  exclude:
+    # No point running rubocop with old rest-client
+    - gemfile: Gemfile-rest-client-1.8.rb
+      env: TASK=rubocop

data/Gemfile-rest-client-1.8.rb

@@ -0,0 +1,11 @@
+# For travis to additionally test rest-client 1.x.
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in kubeclient.gemspec
+gemspec
+
+if dependencies.any? # needed for overriding with recent bundler (1.13 ?)
+  dependencies.delete('rest-client')
+  gem 'rest-client', '= 1.8.0'
+end

data/README.md

@@ -51,6 +51,8 @@ uri = URI::HTTP.build(host: "somehostname", port: 8080)
 client = Kubeclient::Client.new uri
 ```
 
+### SSL
+
 It is also possible to use https and configure ssl with:
 
 ```ruby
@@ -85,6 +87,8 @@ client = Kubeclient::Client.new 'https://localhost:8443/api/' , 'v1',
                                 ssl_options: ssl_options
 ```
 
+### Authentication
+
 If you are using basic authentication or bearer tokens as described
 [here](https://github.com/GoogleCloudPlatform/kubernetes/blob/master/docs/authentication.md) then you can specify one
 of the following:
@@ -135,6 +139,8 @@ client = Kubeclient::Client.new 'https://localhost:8443/api/' , 'v1',
 
 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/).
 
+### Non-blocking IO
+
 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,7 +154,11 @@ client = Kubeclient::Client.new 'https://localhost:8443/api/' , 'v1',
                                 socket_options: socket_options
 ```
 
-You can also use kubeclient with an http proxy server such as tinyproxy. It can be entered as a string or a URI object
+This affects only `.watch_*` sockets, not one-off actions like `.get_*`, `.delete_*` etc.
+
+### Proxies
+
+You can also use kubeclient with an http proxy server such as tinyproxy. It can be entered as a string or a URI object.
 For example:
 ```ruby
 proxy_uri = URI::HTTP.build(host: "myproxyhost", port: 8443)
@@ -156,6 +166,28 @@ client = Kubeclient::Client.new('https://localhost:8443/api/',
                                 :http_proxy_uri => proxy_uri)
 ```
 
+
+### Timeouts
+
+Watching never times out.
+
+One-off actions like `.get_*`, `.delete_*` have a configurable timeout:
+```ruby
+timeouts = {
+  open: 10,  # unit is seconds
+  read: nil  # nil means never time out
+}
+client = Kubeclient::Client.new(
+  'https://localhost:8443/api/', timeouts: timeouts
+)
+```
+
+Default timeouts match `Net::HTTP` and `RestClient`, which unfortunately depends on ruby version:
+- open was infinite up to ruby 2.2, 60 seconds in 2.3+.
+- read is 60 seconds.
+
+If you want ruby-independent behavior, always specify `:open`.
+
 ### Discovery
 
 Discovery from the kube-apiserver is done lazily on method calls so it would not change behavior.

data/lib/kubeclient/common.rb

@@ -26,6 +26,12 @@ module Kubeclient
       ssl_socket_class: nil
     }.freeze
 
+    DEFAULT_TIMEOUTS = {
+      # These do NOT affect watch, watching never times out.
+      open: Net::HTTP.new('127.0.0.1').open_timeout, # depends on ruby version
+      read: Net::HTTP.new('127.0.0.1').read_timeout
+    }.freeze
+
     DEFAULT_HTTP_PROXY_URI = nil
 
     SEARCH_ARGUMENTS = {
@@ -50,6 +56,7 @@ module Kubeclient
       ssl_options: DEFAULT_SSL_OPTIONS,
       auth_options: DEFAULT_AUTH_OPTIONS,
       socket_options: DEFAULT_SOCKET_OPTIONS,
+      timeouts: DEFAULT_TIMEOUTS,
       http_proxy_uri: DEFAULT_HTTP_PROXY_URI
     )
       validate_auth_options(auth_options)
@@ -63,6 +70,9 @@ module Kubeclient
       @ssl_options = ssl_options
       @auth_options = auth_options
       @socket_options = socket_options
+      # Allow passing partial timeouts hash, without unspecified
+      # @timeouts[:foo] == nil resulting in infinite timeout.
+      @timeouts = DEFAULT_TIMEOUTS.merge(timeouts)
       @http_proxy_uri = http_proxy_uri.to_s if http_proxy_uri
 
       if auth_options[:bearer_token]
@@ -215,7 +225,9 @@ module Kubeclient
         ssl_client_key: @ssl_options[:client_key],
         proxy: @http_proxy_uri,
         user: @auth_options[:username],
-        password: @auth_options[:password]
+        password: @auth_options[:password],
+        open_timeout: @timeouts[:open],
+        ClientMixin.restclient_read_timeout_option => @timeouts[:read]
       }
       RestClient::Resource.new(@api_endpoint.merge(path).to_s, options)
     end
@@ -420,6 +432,18 @@ module Kubeclient
       JSON.parse(response)
     end
 
+    def self.restclient_read_timeout_option
+      @restclient_read_timeout_option ||=
+        # RestClient silently accepts unknown options, so check accessors instead.
+        if RestClient::Resource.instance_methods.include?(:read_timeout) # rest-client 2.0
+          :read_timeout
+        elsif RestClient::Resource.instance_methods.include?(:timeout) # rest-client 1.x
+          :timeout
+        else
+          fail ArgumentError("RestClient doesn't support neither :read_timeout nor :timeout")
+        end
+    end
+
     private
 
     def load_entities

data/lib/kubeclient/version.rb

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

data/test/test_kubeclient.rb

@@ -103,6 +103,15 @@ class KubeClientTest < MiniTest::Test
     assert_equal(error_message, exception.message)
   end
 
+  def test_api_timeout
+    stub_request(:get, 'http://localhost:8080/api').to_timeout
+
+    client = Kubeclient::Client.new('http://localhost:8080/api/')
+
+    exception = assert_raises(KubeException) { client.api }
+    assert_match(/(timed out|timeout)/i, exception.message)
+  end
+
   def test_api_valid
     stub_request(:get, 'http://localhost:8080/api')
       .to_return(status: 200, body: open_test_file('versions_list.json'))
@@ -627,6 +636,69 @@ class KubeClientTest < MiniTest::Test
     client.get_persistent_volume_claims
   end
 
+  # Timeouts
+
+  def test_timeouts_defaults
+    client = Kubeclient::Client.new(
+      'http://localhost:8080/api/'
+    )
+    rest_client = client.rest_client
+    assert_default_open_timeout(rest_client.open_timeout)
+    assert_equal(60, read_timeout(rest_client))
+  end
+
+  def test_timeouts_open
+    client = Kubeclient::Client.new(
+      'http://localhost:8080/api/',
+      timeouts: { open: 10 }
+    )
+    rest_client = client.rest_client
+    assert_equal(10, rest_client.open_timeout)
+    assert_equal(60, read_timeout(rest_client))
+  end
+
+  def test_timeouts_read
+    client = Kubeclient::Client.new(
+      'http://localhost:8080/api/',
+      timeouts: { read: 300 }
+    )
+    rest_client = client.rest_client
+    assert_default_open_timeout(rest_client.open_timeout)
+    assert_equal(300, read_timeout(rest_client))
+  end
+
+  def test_timeouts_both
+    client = Kubeclient::Client.new(
+      'http://localhost:8080/api/',
+      timeouts: { open: 10, read: 300 }
+    )
+    rest_client = client.rest_client
+    assert_equal(10, rest_client.open_timeout)
+    assert_equal(300, read_timeout(rest_client))
+  end
+
+  def test_timeouts_infinite
+    client = Kubeclient::Client.new(
+      'http://localhost:8080/api/',
+      timeouts: { open: nil, read: nil }
+    )
+    rest_client = client.rest_client
+    assert_nil(rest_client.open_timeout)
+    assert_nil(read_timeout(rest_client))
+  end
+
+  def read_timeout(rest_client)
+    rest_client.send(Kubeclient::ClientMixin.restclient_read_timeout_option)
+  end
+
+  def assert_default_open_timeout(actual)
+    if RUBY_VERSION >= '2.3'
+      assert_equal(60, actual)
+    else
+      assert_nil(actual)
+    end
+  end
+
   private
 
   # dup method creates a shallow copy which is not good in this case

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kubeclient
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.4.0
 platform: ruby
 authors:
 - Alissa Bonas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-05 00:00:00.000000000 Z
+date: 2017-05-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -147,6 +147,7 @@ files:
 - ".rubocop.yml"
 - ".travis.yml"
 - Gemfile
+- Gemfile-rest-client-1.8.rb
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -258,7 +259,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.6.12
 signing_key: 
 specification_version: 4
 summary: A client for Kubernetes REST api