kubernetes-io 1.0.0.pre.alpha2

data/spec/utils_spec.rb

@@ -0,0 +1,118 @@
+# Copyright 2017 The Kubernetes Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'spec_helper'
+require 'config/matchers'
+require 'fixtures/config/kube_config_hash'
+require 'helpers/file_fixtures'
+
+require 'kubernetes/utils'
+
+# rubocop:disable BlockLength
+describe Kubernetes do
+  describe '.load_incluster_config' do
+    let(:incluster_config) do
+      Kubernetes::InClusterConfig.new.tap do |c|
+        c.instance_variable_set(
+          :@env,
+          Kubernetes::InClusterConfig::SERVICE_HOST_ENV_NAME => 'localhost',
+          Kubernetes::InClusterConfig::SERVICE_PORT_ENV_NAME => '443'
+        )
+        c.instance_variable_set(
+          :@ca_cert,
+          Kubernetes::Testing.file_fixture('certs/ca.crt').to_s
+        )
+        c.instance_variable_set(
+          :@token_file,
+          Kubernetes::Testing.file_fixture('tokens/token').to_s
+        )
+      end
+    end
+
+    it 'should configure client configuration from in-cluster config' do
+      allow(Kubernetes::InClusterConfig)
+        .to receive(:new)
+        .and_return(incluster_config)
+      expected = Kubernetes::Configuration.new do |c|
+        c.scheme = 'https'
+        c.host = 'localhost:443'
+        c.ssl_ca_cert = Kubernetes::Testing.file_fixture('certs/ca.crt').to_s
+        c.api_key['authorization'] = 'Bearer token1'
+      end
+      actual = Kubernetes::Configuration.new
+
+      Kubernetes.load_incluster_config(client_configuration: actual)
+      expect(actual).to be_same_configuration_as(expected)
+    end
+  end
+
+  describe '.load_kube_config' do
+    file = Kubernetes::Testing.file_fixture('config/config').to_s
+    let(:kube_config) { Kubernetes::KubeConfig.new(file, TEST_KUBE_CONFIG) }
+
+    it 'should configure client configuration from kube_config' do
+      kubeconfig_path = 'kubeconfig/path'
+      allow(Kubernetes::KubeConfig)
+        .to receive(:new)
+        .with(kubeconfig_path)
+        .and_return(kube_config)
+      expected = Kubernetes::Configuration.new do |c|
+        c.scheme = 'https'
+        c.host = 'test-host:443'
+        c.ssl_ca_cert = Kubernetes::Testing.file_fixture('certs/ca.crt').to_s
+        c.cert_file = Kubernetes::Testing.file_fixture('certs/client.crt').to_s
+        c.key_file = Kubernetes::Testing.file_fixture('certs/client.key').to_s
+      end
+      actual = Kubernetes::Configuration.new
+
+      Kubernetes.load_kube_config(
+        kubeconfig_path,
+        context: 'context_ssl',
+        client_configuration: actual
+      )
+      expect(actual).to be_same_configuration_as(expected)
+    end
+  end
+
+  context '#create_temp_file_with_base64content' do
+    before do
+      Kubernetes.clear_temp_files
+    end
+
+    context 'when it is called at first time' do
+      it 'should return temp file path' do
+        expected_path = 'tempfile-path'
+        content = TEST_DATA_BASE64
+        io = double('io')
+        expect(io).to receive(:path).and_return(expected_path)
+        expect(io).to receive(:write).with(TEST_DATA)
+        allow(Tempfile).to receive(:open).and_yield(io)
+
+        path = Kubernetes.create_temp_file_with_base64content(content)
+        expect(path).to eq(expected_path)
+      end
+    end
+
+    context 'when it is already called' do
+      it 'should return cached value' do
+        content = TEST_DATA_BASE64
+        expected_path = Kubernetes.create_temp_file_with_base64content(content)
+
+        path = Kubernetes.create_temp_file_with_base64content(content)
+        expect(path).to eq(expected_path)
+      end
+    end
+  end
+end
+# rubocop:enable BlockLength

data/spec/watch_spec.rb

@@ -0,0 +1,36 @@
+# Copyright 2019 The Kubernetes Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'spec_helper'
+require 'kubernetes/watch'
+
+describe 'WatchClient' do
+  it 'should construct correctly' do
+    Kubernetes::Watch.new(nil)
+  end
+
+  it 'should parse chunks correctly' do
+    client = Kubernetes::Watch.new(nil)
+    last = ''
+
+    last, data = client.split_lines(last, "foo\nbar\nba")
+
+    expect(last).to eq('ba')
+    expect(data).to eq(%w[foo bar])
+
+    last, data = client.split_lines(last, "z\nblah\n")
+    expect(last).to eq('')
+    expect(data).to eq(%w[baz blah])
+  end
+end

data/src/kubernetes/config/error.rb

@@ -0,0 +1,17 @@
+# Copyright 2017 The Kubernetes Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Kubernetes
+  class ConfigError < RuntimeError; end
+end

data/src/kubernetes/config/incluster_config.rb

@@ -0,0 +1,80 @@
+# Copyright 2017 The Kubernetes Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'kubernetes/configuration'
+require 'kubernetes/config/error'
+
+module Kubernetes
+  # The InClusterConfig class represents configuration for authn/authz in a
+  # Kubernetes cluster.
+  class InClusterConfig
+    # rubocop:disable LineLength
+    SERVICE_HOST_ENV_NAME = 'KUBERNETES_SERVICE_HOST'.freeze
+    SERVICE_PORT_ENV_NAME = 'KUBERNETES_SERVICE_PORT'.freeze
+    SERVICE_TOKEN_FILENAME = '/var/run/secrets/kubernetes.io/serviceaccount/token'.freeze
+    SERVICE_CA_CERT_FILENAME = '/var/run/secrets/kubernetes.io/serviceaccount/ca.crt'.freeze
+    # rubocop:enable LineLength
+
+    attr_accessor :host
+    attr_accessor :port
+    attr_accessor :token
+
+    def validate
+      unless (self.host = env[SERVICE_HOST_ENV_NAME]) &&
+             (self.port = env[SERVICE_PORT_ENV_NAME])
+        raise ConfigError, 'Service host/port is not set'
+      end
+
+      # rubocop:disable LineLength
+      raise ConfigError, 'Service token file does not exists' unless File.file?(token_file)
+      raise ConfigError, 'Service token file does not exists' unless File.file?(ca_cert)
+      # rubocop:enable LineLength
+    end
+
+    def self.in_cluster?
+      File.exist?(SERVICE_TOKEN_FILENAME) &&
+        File.exist?(SERVICE_CA_CERT_FILENAME)
+    end
+
+    def env
+      @env ||= ENV
+      @env
+    end
+
+    def ca_cert
+      @ca_cert ||= SERVICE_CA_CERT_FILENAME
+      @ca_cert
+    end
+
+    def token_file
+      @token_file ||= SERVICE_TOKEN_FILENAME
+      @token_file
+    end
+
+    def load_token
+      File.open(token_file) do |io|
+        self.token = io.read.chomp
+      end
+    end
+
+    def configure(configuration)
+      validate
+      load_token
+      configuration.api_key['authorization'] = "Bearer #{token}"
+      configuration.scheme = 'https'
+      configuration.host = "#{host}:#{port}"
+      configuration.ssl_ca_cert = ca_cert
+    end
+  end
+end

data/src/kubernetes/config/kube_config.rb

@@ -0,0 +1,171 @@
+# Copyright 2017 The Kubernetes Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'base64'
+require 'yaml'
+require 'tempfile'
+require 'uri'
+
+require 'kubernetes/api_client'
+require 'kubernetes/configuration'
+require 'kubernetes/config/error'
+require 'kubernetes/utils'
+
+module Kubernetes
+  # rubocop:disable ClassLength
+  # The KubeConfig class represents configuration based on a YAML
+  # representation.
+  class KubeConfig
+    KUBE_CONFIG_DEFAULT_LOCATION = File.expand_path('~/.kube/config')
+    AUTH_KEY = 'authorization'.freeze
+
+    class << self
+      def list_context_names(config_file = KUBE_CONFIG_DEFAULT_LOCATION)
+        config = new(config_file)
+        config.list_context_names
+      end
+    end
+
+    attr_accessor :path
+    attr_writer :config
+
+    def initialize(path, config_hash = nil)
+      @path = path
+      @config = config_hash
+    end
+
+    def base_path
+      File.dirname(path)
+    end
+
+    def config
+      @config ||= File.open(path) do |io|
+        ::YAML.safe_load(io.read)
+      end
+    end
+
+    def configure(configuration, context_name = nil)
+      context = context_name ? find_context(context_name) : current_context
+      return unless context
+
+      user = context['user'] || {}
+      cluster = context['cluster'] || {}
+
+      configuration.tap do |c|
+        c.api_key[AUTH_KEY] = user[AUTH_KEY] if user[AUTH_KEY]
+
+        init_server(cluster, user, c)
+      end
+    end
+
+    def init_server(cluster, user, config)
+      return unless (server = cluster['server'])
+
+      server = URI.parse(server)
+      config.scheme = server.scheme
+      host = "#{server.host}:#{server.port}"
+      host = "#{server.userinfo}@#{host}" if server.userinfo
+      config.host = host
+      config.base_path = server.path
+
+      return unless server.scheme == 'https'
+
+      setup_ssl(cluster, user, config)
+    end
+
+    def setup_ssl(cluster, user, config)
+      # rubocop:disable DoubleNegation
+      config.verify_ssl = !!cluster['verify-ssl']
+      config.verify_ssl_host = !!cluster['verify-ssl']
+      # rubocop:enable DoubleNegation
+
+      config.ssl_ca_cert = cluster['certificate-authority']
+      config.cert_file = user['client-certificate']
+      config.key_file = user['client-key']
+    end
+
+    def find_cluster(name)
+      find_by_name(config['clusters'], 'cluster', name).tap do |cluster|
+        Kubernetes.create_temp_file_and_set(cluster, 'certificate-authority')
+        cluster['verify_ssl'] = !cluster['insecure-skip-tls-verify']
+      end
+    end
+
+    def find_user(name)
+      find_by_name(config['users'], 'user', name).tap do |user|
+        next unless user
+
+        Kubernetes.create_temp_file_and_set(user, 'client-certificate')
+        Kubernetes.create_temp_file_and_set(user, 'client-key')
+        load_token_file(user)
+        setup_auth(user)
+      end
+    end
+
+    def load_token_file(user)
+      # If tokenFile is specified, then set token
+      return unless !user['token'] && user['tokenFile']
+
+      File.open(user['tokenFile']) do |io|
+        user['token'] = io.read.chomp
+      end
+    end
+
+    # rubocop:disable AbcSize
+    def setup_auth(user)
+      # Convert token field to http header
+      if user['token']
+        user['authorization'] = "Bearer #{user['token']}"
+      elsif user['username'] && user['password']
+        user_pass = "#{user['username']}:#{user['password']}"
+        user['authorization'] = "Basic #{Base64.strict_encode64(user_pass)}"
+      elsif user['auth-provider'] && user['auth-provider']['name'] == 'azure'
+        token = user['auth-provider']['config']['access-token']
+        user['authorization'] = "Bearer #{token}"
+      end
+    end
+    # rubocop:enable AbcSize
+
+    def list_context_names
+      config['contexts'].map { |e| e['name'] }
+    end
+
+    def find_context(name)
+      find_by_name(config['contexts'], 'context', name).tap do |context|
+        if context['cluster']
+          context['cluster'] = find_cluster(context['cluster'])
+        end
+        if context['user'] && !context['user'].empty?
+          context['user'] = find_user(context['user'])
+        end
+      end
+    end
+
+    def current_context
+      return unless config
+
+      find_context(config['current-context'])
+    end
+
+    protected
+
+    def find_by_name(list, key, name)
+      obj = list.find { |item| item['name'] == name }
+      raise ConfigError, "#{key}: #{name} not found" unless obj
+
+      obj[key].dup if obj[key]
+    end
+  end
+  # rubocop:enable ClassLength
+end

data/src/kubernetes/loader.rb

@@ -0,0 +1,55 @@
+# Copyright 2019 The Kubernetes Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'kubernetes/config/incluster_config'
+require 'kubernetes/config/kube_config'
+
+module Kubernetes
+  # Configuration is a utility class for loading kubernetes configurations
+  class Configuration
+    def self.default_config
+      result = Configuration.new
+      return result if load_local_config(result)
+
+      # In cluster config
+      if InClusterConfig.in_cluster?
+        k_config = InClusterConfig.new
+        k_config.configure(result)
+        return result
+      end
+
+      result.scheme = 'http'
+      result.host = 'localhost:8080'
+      result
+    end
+
+    def self.load_local_config(result)
+      # KUBECONFIG environment variable
+      kc = (ENV['KUBECONFIG']).to_s
+      return load_file_config(kc, result) if File.exist?(kc)
+
+      # default home location
+      kc = "#{ENV['HOME']}/.kube/config"
+      return unless File.exist?(kc)
+
+      load_file_config(kc, result)
+    end
+
+    def self.load_file_config(file, result)
+      k_config = KubeConfig.new(file)
+      k_config.configure(result)
+      result
+    end
+  end
+end