dapp 0.10.2 → 0.36.24

data/lib/dapp/kube/kubernetes/client.rb

@@ -0,0 +1,314 @@
+module Dapp
+  module Kube
+    module Kubernetes
+      # TODO endpoints can be gathered from api-server by api discovery.
+      K8S_API_ENDPOINTS = {
+        '1.6' => {
+          '/api/v1' => [:service, :replicationcontroller, :pod, :podtemplate, ],
+          '/apis/apps/v1beta1' => [:deployment, :statefulset, ],
+          '/apis/extensions/v1beta1' => [:replicaset, :daemonset, ],
+          '/apis/batch/v1' => [:job, ],
+          '/apis/batch/v2aplha1' => [:cronjob, ],
+        },
+        '1.7' => {
+          '/api/v1' => [:service, :replicationcontroller, :pod, :podtemplate, ],
+          '/apis/apps/v1beta1' => [:deployment, :statefulset, ],
+          '/apis/extensions/v1beta1' => [:replicaset, :daemonset, ],
+          '/apis/batch/v1' => [:job, ],
+          '/apis/batch/v2aplha1' => [:cronjob, ],
+        },
+        '1.8' => {
+          '/api/v1' => [:service, :replicationcontroller, :pod, :podtemplate, ],
+          '/apis/apps/v1beta2' => [:daemonset, :deployment, :replicaset, :statefulset, ],
+          '/apis/batch/v1' => [:job, ],
+          '/apis/batch/v1beta1' => [:cronjob, ],
+        },
+        '1.9' => {
+          '/api/v1' => [:service, :replicationcontroller, :pod, :podtemplate, ],
+          '/apis/apps/v1' => [:daemonset, :deployment, :replicaset, :statefulset, ],
+          '/apis/batch/v1' => [:job, ],
+          '/apis/batch/v1beta1' => [:cronjob, ],
+        },
+        '1.10' => {
+          '/api/v1' => [:service, :replicationcontroller, :pod, :podtemplate, ],
+          '/apis/apps/v1' => [:daemonset, :deployment, :replicaset, :statefulset, ],
+          '/apis/batch/v1' => [:job, ],
+          '/apis/batch/v1beta1' => [:cronjob, ],
+        },
+        '1.11' => {
+          '/api/v1' => [:service, :replicationcontroller, :pod, :podtemplate, ],
+          '/apis/apps/v1' => [:daemonset, :deployment, :replicaset, :statefulset, ],
+          '/apis/batch/v1' => [:job, ],
+          '/apis/batch/v1beta1' => [:cronjob, ],
+        },
+        'stable' => {
+          '/api/v1' => [:service, :replicationcontroller, :pod, :podtemplate, ],
+          '/apis/batch/v1' => [:job, ],
+        },
+      }
+
+      class Client
+        include Helper::YAML
+        extend Helper::YAML
+
+        ::Dapp::Dapp::Shellout::Base.default_env_keys << 'KUBECONFIG'
+
+        attr_reader :config
+        attr_reader :context
+        attr_reader :namespace
+        attr_reader :timeout
+
+        def initialize(config, context, namespace, timeout: nil)
+          @config = config
+          @context = context
+          @namespace = namespace
+          @timeout = timeout
+          @query_parameters = {}
+          @cluster_version
+        end
+
+        # Чтобы не перегружать методы явной передачей namespace.
+        # Данный метод может пригодиться только в ситуации, когда надо указать другой namespace,
+        # в большинстве случаев используется namespace из конструктора.
+        def with_namespace(namespace, &blk)
+          old_namespace = @namespace
+          begin
+            @namespace = namespace
+            return yield
+          ensure
+            @namespace = old_namespace
+          end
+        end
+
+        def with_query(query, &blk)
+          old_query = @query_parameters
+          begin
+            @query_parameters = query
+            return yield
+          ensure
+            @query_parameters = old_query
+          end
+        end
+
+        # NOTICE: Название метода аналогично kind'у выдаваемого результата.
+        # NOTICE: В данном случае в результате kind=DeploymentList.
+        # NOTICE: Методы создания/обновления/удаления сущностей kubernetes заканчиваются на '!'. Например, create_deployment!.
+        # В каждом методе происходит выбор api на основе версии кластера
+
+        def resource_endpoint_path(resource)
+          K8S_API_ENDPOINTS[cluster_version()].map do |path, resources|
+            resources.include?(resource) ? path : nil
+          end.compact.first
+        end
+
+        [
+          :service, :replicationcontroller, :pod, :podtemplate,
+          :daemonset, :deployment, :replicaset, :statefulset,
+          :job,
+          :cronjob,
+        ].each do |resource|
+          define_method :"#{resource}_list" do |**query_parameters|
+            api_path = resource_endpoint_path(resource)
+            request!(:get, "#{api_path}/namespaces/#{namespace}/#{resource}s", **query_parameters)
+          end
+
+          define_method resource do |name, **query_parameters|
+            api_path = resource_endpoint_path(resource)
+            request!(:get, "#{api_path}/namespaces/#{namespace}/#{resource}s/#{name}", **query_parameters)
+          end
+
+          define_method "#{resource}_status" do |name, **query_parameters|
+            api_path = resource_endpoint_path(resource)
+            request!(:get, "#{api_path}/namespaces/#{namespace}/#{resource}s/#{name}/status", **query_parameters)
+          end
+
+          define_method :"create_#{resource}!" do |spec, **query_parameters|
+            api_path = resource_endpoint_path(resource)
+            request!(:post, "#{api_path}/namespaces/#{namespace}/#{resource}s", body: spec, **query_parameters)
+          end
+
+          define_method :"replace_#{resource}!" do |name, spec, **query_parameters|
+            api_path = resource_endpoint_path(resource)
+            request!(:put, "#{api_path}/namespaces/#{namespace}/#{resource}s/#{name}", body: spec, **query_parameters)
+          end
+
+          define_method :"delete_#{resource}!" do |name, **query_parameters|
+            api_path = resource_endpoint_path(resource)
+            request!(:delete, "#{api_path}/namespaces/#{namespace}/#{resource}s/#{name}", **query_parameters)
+          end
+
+          define_method :"delete_#{resource}s!" do |**query_parameters|
+            api_path = resource_endpoint_path(resource)
+            request!(:delete, "#{api_path}/namespaces/#{namespace}/#{resource}s", **query_parameters)
+          end
+
+          define_method :"#{resource}?" do |name, **query_parameters|
+            public_send(:"#{resource}_list", **query_parameters)['items'].map { |item| item['metadata']['name'] }.include?(name)
+          end
+        end
+
+
+        def namespace_list(**query_parameters)
+          request!(:get, '/api/v1/namespaces', **query_parameters)
+        end
+
+        def namespace?(name, **query_parameters)
+          namespace_list(**query_parameters)['items'].map { |item| item['metadata']['name'] }.include?(name)
+        end
+
+        def create_namespace!(name, **query_parameters)
+          request!(:post, '/api/v1/namespaces', body: { metadata: { name: name } }, **query_parameters)
+        end
+
+        def delete_namespace!(name, **query_parameters)
+          request!(:delete, "/api/v1/namespaces/#{name}", **query_parameters)
+        end
+
+        # minikube returns empty major and minor. Fallback to stable only apis for minikube setup
+        def cluster_version(**query_parameters)
+          version_obj = request!(:get, "/version", **query_parameters)
+          @cluster_version ||= begin
+            major = version_obj['major']
+            minor = version_obj['minor'].gsub(/\+$/,'')
+            k8s_version = "#{major}.#{minor}"
+            if K8S_API_ENDPOINTS.has_key?(k8s_version)
+              k8s_version
+            else
+              "stable"
+            end
+          end
+        end
+
+        def pod_log(name, follow: false, **query_parameters, &blk)
+          excon_parameters = follow ? { response_block: blk } : {}
+          request!(:get,
+                   "/api/v1/namespaces/#{namespace}/pods/#{name}/log",
+                   excon_parameters: excon_parameters,
+                   response_body_parameters: {json: false},
+                   **{ follow: follow }.merge(query_parameters))
+        rescue Excon::Error::Timeout
+          raise Error::Timeout
+        rescue Error::Base => err
+          if err.net_status[:code] == :bad_request and err.net_status[:data][:response_body]
+            msg = err.net_status[:data][:response_body]['message']
+            if msg.end_with? 'ContainerCreating'
+              raise Error::Pod::ContainerCreating, data: err.net_status[:data]
+            elsif msg.end_with? 'PodInitializing'
+              raise Error::Pod::PodInitializing, data: err.net_status[:data]
+            end
+          end
+
+          raise
+        end
+
+        def event_list(**query_parameters)
+          request!(:get, "/api/v1/namespaces/#{namespace}/events", **query_parameters)
+        end
+
+        protected
+
+        # query_parameters — соответствует 'Query Parameters' в документации kubernetes
+        # excon_parameters — соответствует connection-опциям Excon
+        # body — hash для http-body, соответствует 'Body Parameters' в документации kubernetes, опционален
+        def request!(method, path, body: nil, excon_parameters: {}, response_body_parameters: {}, **query_parameters)
+          if method == :get
+            excon_parameters[:idempotent] = true
+            excon_parameters[:retry_limit] = 6
+            excon_parameters[:retry_interval] = 5
+          end
+
+          excon_parameters[:connect_timeout] ||= timeout
+          excon_parameters[:read_timeout] ||= timeout
+          excon_parameters[:write_timeout] ||= timeout
+
+          with_connection(excon_parameters: excon_parameters) do |conn|
+            request_parameters = {method: method, path: path, query: @query_parameters.merge(query_parameters)}
+            request_parameters[:body] = JSON.dump(body) if body
+            load_body! conn.request(request_parameters), request_parameters, **response_body_parameters
+          end
+        end
+
+        def load_body!(response, request_parameters, json: true)
+          response_ok = response.status.to_s.start_with? '2'
+
+          if response_ok
+            if json
+              JSON.parse(response.body)
+            else
+              response.body
+            end
+          else
+            err_data = {}
+            err_data[:response_http_status] = response.status
+            err_data[:response_raw_body] = response.body
+            if response_body = (JSON.parse(response.body) rescue nil)
+              err_data[:response_body] = response_body
+            end
+            err_data[:request_parameters] = request_parameters
+
+            if response.status.to_s.start_with? '5'
+              raise Error::Default, code: :server_error, data: err_data
+            elsif response.status.to_s == '404'
+              case err_data.fetch(:response_body, {}).fetch('details', {})['kind']
+              when 'pods'
+                raise Error::Pod::NotFound, data: err_data
+              else
+                raise Error::NotFound, data: err_data
+              end
+            elsif not response.status.to_s.start_with? '2'
+              raise Error::Base, code: :bad_request, data: err_data
+            end
+          end
+        end
+
+        def with_connection(excon_parameters: {}, &blk)
+          connection = begin
+            context_config = config.context_config(context)
+            cluster_config = config.cluster_config(context_config['cluster'])
+            Excon.new(cluster_config['server'], **kube_server_options(excon_parameters)).tap(&:get)
+          rescue Excon::Error::Socket => err
+            raise Error::ConnectionRefused,
+                  code: :server_connection_refused,
+                  data: { url: cluster_config['server'], error: err.message }
+          end
+
+          return yield connection
+        end
+
+        def kube_server_options(excon_parameters = {})
+          {}.tap do |opts|
+            context_config = config.context_config(context)
+            user_config = config.user_config(context_config['user'])
+            cluster_config = config.cluster_config(context_config['cluster'])
+
+            client_cert = user_config['client-certificate']
+            opts[:client_cert] = client_cert if client_cert
+
+            client_cert_data= user_config['client-certificate-data']
+            opts[:client_cert_data] = Base64.decode64(client_cert_data) if client_cert_data
+
+            client_key = user_config['client-key']
+            opts[:client_key] = client_key if client_key
+
+            client_key_data = user_config['client-key-data']
+            opts[:client_key_data] = Base64.decode64(client_key_data) if client_key_data
+
+            ssl_cert_store = OpenSSL::X509::Store.new
+            if ssl_ca_file = cluster_config['certificate-authority']
+              ssl_cert_store.add_file ssl_ca_file
+            elsif ssl_ca_data = cluster_config['certificate-authority-data']
+              ssl_cert_store.add_cert OpenSSL::X509::Certificate.new(Base64.decode64(ssl_ca_data))
+            end
+            opts[:ssl_cert_store] = ssl_cert_store
+
+            opts[:ssl_ca_file] = nil
+
+            opts[:middlewares] = [*Excon.defaults[:middlewares], Excon::Middleware::RedirectFollower]
+
+            opts.merge!(excon_parameters)
+          end
+        end
+      end # Client
+    end # Kubernetes
+  end # Kube
+end # Dapp

data/lib/dapp/kube/kubernetes/config.rb

@@ -0,0 +1,132 @@
+module Dapp
+  module Kube
+    module Kubernetes
+      class Config
+        extend Helper::YAML
+        extend Dapp::Shellout::Base
+
+        class << self
+          def new_auto_if_available
+            if Kubernetes::Config.kubectl_available?
+              Kubernetes::Config.new_from_kubectl
+            elsif ENV['KUBECONFIG']
+              Kubernetes::Config.new_from_kubeconfig(ENV['KUBECONFIG'])
+            else
+              default_path = File.join(ENV['HOME'], '.kube/config')
+              if File.exists? default_path
+                Kubernetes::Config.new_from_kubeconfig(default_path)
+              end
+            end
+          end
+
+          def new_auto
+            new_auto_if_available.tap do |cfg|
+              raise(Kubernetes::Error::Default,
+                code: :config_not_found,
+                data: { },
+              ) if cfg.nil?
+            end
+          end
+
+          def new_from_kubeconfig(path)
+            unless File.exists?(path)
+              raise(Kubernetes::Error::Default,
+                code: :config_file_not_found,
+                data: { config_path: path }
+              )
+            end
+            self.new yaml_load_file(path), path
+          end
+
+          def kubectl_available?
+            shellout("kubectl").exitstatus.zero?
+          end
+
+          def new_from_kubectl
+            cmd_res = shellout(
+              "kubectl config view --raw",
+              env: {"KUBECONFIG" => ENV["KUBECONFIG"]}
+            )
+
+            shellout_cmd_should_succeed! cmd_res
+
+            self.new YAML.load(cmd_res.stdout), "kubectl config view --raw"
+          end
+        end # << self
+
+        attr_reader :config_hash, :config_path
+
+        def initialize(config_hash, config_path)
+          @config_hash = config_hash
+          @config_path = config_path
+        end
+
+        def context_names
+          config_hash.fetch('contexts', []).map {|context| context['name']}
+        end
+
+        def current_context_name
+          @current_context_name ||= begin
+            config_hash['current-context'] || begin
+              if (context = config_hash.fetch('contexts', []).first)
+                warn "[WARN] .kube/config current-context is not set, using first context '#{context['name']}'"
+                context['name']
+              end
+            end
+          end
+        end
+
+        def context_config(context_name)
+          res = config_hash.fetch('contexts', [])
+            .find {|context| context['name'] == context_name}
+
+          raise(Kubernetes::Error::Default,
+            code: :context_config_not_found,
+            data: {config_path: config_path,
+                    config: config_hash,
+                    context_name: context_name}
+          ) if res.nil?
+
+          res['context']
+        end
+
+        def user_config(user_name)
+          res = config_hash.fetch('users', [])
+            .find {|user| user['name'] == user_name}
+
+          raise(Kubernetes::Error::Default,
+            code: :user_config_not_found,
+            data: {config_path: config_path,
+                    user: user_name}
+          ) if res.nil?
+
+          res['user']
+        end
+
+        def cluster_config(cluster_name)
+          res = config_hash.fetch('clusters', [])
+            .find {|cluster| cluster['name'] == cluster_name}
+
+          raise(Kubernetes::Error::Default,
+            code: :cluster_config_not_found,
+            data: {config_path: config_path,
+                  cluster: cluster_name}
+          ) if res.nil?
+
+          res['cluster']
+        end
+
+        def cluster_name(context_name)
+          cfg = context_config(context_name)
+          cfg['cluster'] if cfg
+        end
+
+        def namespace(context_name)
+          cfg = context_config(context_name)
+          cfg['namespace'] if cfg
+        end
+
+      end # Kubeconfig
+    end # Kubernetes
+  end # Kube
+end # Dapp

data/lib/dapp/kube/kubernetes/error.rb

@@ -0,0 +1,15 @@
+module Dapp
+  module Kube
+    module Kubernetes::Error
+      class Base < ::Dapp::Error::Base
+        def initialize(**net_status)
+          super(**net_status, context: :kubernetes)
+        end
+      end
+
+      class Default < Base
+        include ::Dapp::Error::Mod::User
+      end
+    end # Kubernetes::Error
+  end # Kube
+end # Dapp

data/lib/dapp/kube/kubernetes/manager/base.rb

@@ -0,0 +1,15 @@
+module Dapp
+  module Kube
+    module Kubernetes::Manager
+      class Base
+        attr_reader :dapp
+        attr_reader :name
+
+        def initialize(dapp, name)
+          @dapp = dapp
+          @name = name
+        end
+      end # Base
+    end # Kubernetes::Manager
+  end # Kube
+end # Dapp

data/lib/dapp/kube/kubernetes/manager/container.rb

@@ -0,0 +1,103 @@
+module Dapp
+  module Kube
+    module Kubernetes::Manager
+      class Container < Base
+        attr_reader :pod_manager
+
+        def initialize(dapp, name, pod_manager)
+          super(dapp, name)
+
+          @pod_manager = pod_manager
+          @processed_containers_ids = []
+          @processed_log_till_time = nil
+          @processed_log_timestamps = Set.new
+        end
+
+        def watch_till_terminated!
+          pod = Kubernetes::Client::Resource::Pod.new(dapp.kubernetes.pod(pod_manager.name))
+          _, container_state_data = pod.container_state(name)
+          return if @processed_containers_ids.include? container_state_data['containerID']
+
+          pod_manager.wait_till_launched!
+
+          pod = Kubernetes::Client::Resource::Pod.new(dapp.kubernetes.pod(pod_manager.name))
+          container_state, container_state_data = pod.container_state(name)
+
+          dapp.log_process("Watch pod's '#{pod_manager.name}' container '#{name}' log") do
+            loop do
+              pod = Kubernetes::Client::Resource::Pod.new(dapp.kubernetes.pod(pod_manager.name))
+              container_state, container_state_data = pod.container_state(name)
+
+              if container_state == "waiting"
+                if container_state_data["reason"] == "RunContainerError"
+                  raise Kubernetes::Error::Default, code: :container_stuck, data: {
+                    state_reason: container_state_data["reason"],
+                    state_message: container_state_data["message"],
+                    state: container_state,
+                    pod_name: pod_manager.name,
+                    container_name: name
+                  }
+                else
+                  sleep 0.1
+                  next
+                end
+              end
+
+              chunk_lines_by_time = {}
+              begin
+                chunk_lines_by_time = dapp.kubernetes.pod_log(pod_manager.name, container: name, timestamps: true, sinceTime: @processed_log_till_time)
+                  .lines
+                  .map(&:strip)
+                  .map do |line|
+                    timestamp, _, data = line.partition(' ')
+                    [timestamp, data]
+                  end
+                  .reject {|timestamp, _| @processed_log_timestamps.include? timestamp}
+              rescue Kubernetes::Client::Error::Pod::ContainerCreating, Kubernetes::Client::Error::Pod::PodInitializing
+                sleep 0.1
+                next
+              rescue Kubernetes::Client::Error::Base => err
+                dapp.log_warning("#{dapp.log_time}Error while fetching pod's #{pod_manager.name} logs: #{err.message}", stream: dapp.service_stream)
+                break
+              end
+
+              chunk_lines_by_time.each do |timestamp, data|
+                dapp.log("[#{timestamp}] #{data}")
+                @processed_log_timestamps.add timestamp
+              end
+
+              if container_state == 'terminated'
+                failed = (container_state_data['exitCode'].to_i != 0)
+
+                dapp.log_warning("".tap do |msg|
+                  msg << "Pod's '#{pod_manager.name}' container '#{name}' has been terminated unsuccessfuly: "
+                  msg << container_state_data.to_s
+                end) if failed
+
+                @processed_containers_ids << container_state_data['containerID']
+
+                break
+              end
+
+              @processed_log_till_time = chunk_lines_by_time.last.first if chunk_lines_by_time.any?
+
+              sleep 0.1 if chunk_lines_by_time.empty?
+            end
+          end # log_process
+        end
+
+        def done?
+          pod = Kubernetes::Client::Resource::Pod.new(dapp.kubernetes.pod(pod_manager.name))
+          container_state, container_state_data = pod.container_state(name)
+          if container_state == 'terminated'
+            failed = (container_state_data['exitCode'].to_i != 0)
+            return true if pod.restart_policy == 'Never'
+            return true if not failed and pod.restart_policy == 'OnFailure'
+          end
+
+          return false
+        end
+      end # Container
+    end # Kubernetes::Manager
+  end # Kube
+end # Dapp