dapp 0.13.12 → 0.13.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ef826e2fa06f5f2d5a3a805f2d1c1899606e77f6
-  data.tar.gz: fc77c87ea858e86b0c258539529cc081bee15b35
+  metadata.gz: 02f03bab43041fee2897358ca3262e4d3c712d69
+  data.tar.gz: 68a67d7bc551e1a4b27a40579dad44fd2c5509ec
 SHA512:
-  metadata.gz: 28ccc7920b25918c3ad23483ec7dd1ee81e4c187b4734ed6b0e4d31a911fe0fccd20decba500262fa1162692dace01fc0a53468b0c6e4f18cd5d5481290d7952
-  data.tar.gz: 26154a43ce123ca6f883701d49ddc6ba0fb1a930ef8fe61cb68612490029d3a5c2177a86fa562f2f8136a17bcb62e73e01be319e78328d96a6a0706b559c64d4
+  metadata.gz: 324d9d5c00cb1f4fe580ac4a0ea403559513e61287e9828b358223a7c8594f4717946c3baa6a8b832fc15c023c406bddb65d49a4a7673e96d8e1771c576c87d2
+  data.tar.gz: 494400490d133e1fc264c8cfd2352026a52c39a5f5644c6f7d917fc65d05c1d87fcf1a0c15e2148d76b175b1e1fe14678060100f9b344d8805f67f5f7a8339ff

data/config/en/net_status.yml

@@ -8,6 +8,8 @@ en:
       dimg_not_run: "Dimg run failed!"
       git_branch_without_name: "Dimg has specific revision that isn't associated with a branch name!"
       ci_environment_required: 'CI environment required (Travis or GitLab CI)!'
+    kube:
+      deploy_timeout: "Deploy timeout!"
     dappfile:
       incorrect: "Dappfile with `%{error}`:\n%{message}"
     build:

data/lib/dapp.rb

@@ -113,10 +113,16 @@ require 'dapp/kube/kubernetes/client/error'
 require 'dapp/kube/kubernetes/client/resource/base'
 require 'dapp/kube/kubernetes/client/resource/pod'
 require 'dapp/kube/kubernetes/client/resource/job'
+require 'dapp/kube/kubernetes/client/resource/deployment'
+require 'dapp/kube/kubernetes/client/resource/replicaset'
+require 'dapp/kube/kubernetes/client/resource/event'
 require 'dapp/kube/kubernetes/manager/base'
 require 'dapp/kube/kubernetes/manager/pod'
 require 'dapp/kube/kubernetes/manager/container'
 require 'dapp/kube/kubernetes/manager/job'
+require 'dapp/kube/kubernetes/manager/deployment'
+require 'dapp/kube/helm'
+require 'dapp/kube/helm/release'
 require 'dapp/kube/cli/command/base'
 require 'dapp/kube/cli/command/kube'
 require 'dapp/kube/cli/command/kube/deploy'

data/lib/dapp/deployment/kube_app.rb

@@ -109,133 +109,6 @@ module Dapp
         _wait_for_deployment(d, old_d_revision: old_d_revision)
       end
 
-      # NOTICE: old_d_revision на данный момент выводится на экран как информация для дебага.
-      # NOTICE: deployment.kubernetes.io/revision не меняется при изменении количества реплик, поэтому
-      # NOTICE: критерий ожидания по изменению ревизии не верен.
-      # NOTICE: Однако, при обновлении deployment ревизия сбрасывается и ожидание переустановки этой ревизии
-      # NOTICE: является одним из критериев завершения ожидания на данный момент.
-      def _wait_for_deployment(d, old_d_revision: nil)
-        app.deployment.dapp.log_process("Waiting for kubernetes Deployment #{d['metadata']['name']} readiness") do
-          known_events_by_pod = {}
-
-          loop do
-            d_revision = d.fetch('metadata', {}).fetch('annotations', {}).fetch('deployment.kubernetes.io/revision', nil)
-
-            app.deployment.dapp.log_step("[#{Time.now}] Poll kubernetes Deployment status")
-            app.deployment.dapp.with_log_indent do
-              app.deployment.dapp.log_info("Target replicas: #{_field_value_for_log(d['spec']['replicas'])}")
-              app.deployment.dapp.log_info("Updated replicas: #{_field_value_for_log(d['status']['updatedReplicas'])} / #{_field_value_for_log(d['spec']['replicas'])}")
-              app.deployment.dapp.log_info("Available replicas: #{_field_value_for_log(d['status']['availableReplicas'])} / #{_field_value_for_log(d['spec']['replicas'])}")
-              app.deployment.dapp.log_info("Ready replicas: #{_field_value_for_log(d['status']['readyReplicas'])} / #{_field_value_for_log(d['spec']['replicas'])}")
-              app.deployment.dapp.log_info("Old deployment.kubernetes.io/revision: #{_field_value_for_log(old_d_revision)}")
-              app.deployment.dapp.log_info("Current deployment.kubernetes.io/revision: #{_field_value_for_log(d_revision)}")
-            end
-
-            rs = nil
-            if d_revision
-              # Находим актуальный, текущий ReplicaSet.
-              # Если такая ситуация, когда есть несколько подходящих по revision ReplicaSet, то берем старейший по дате создания.
-              # Также делает kubectl: https://github.com/kubernetes/kubernetes/blob/d86a01570ba243e8d75057415113a0ff4d68c96b/pkg/controller/deployment/util/deployment_util.go#L664
-              rs = app.deployment.kubernetes.replicaset_list['items']
-                .select do |_rs|
-                  Array(_rs['metadata']['ownerReferences']).any? do |owner_reference|
-                    owner_reference['uid'] == d['metadata']['uid']
-                  end
-                end
-                .select do |_rs|
-                  rs_revision = _rs.fetch('metadata', {}).fetch('annotations', {}).fetch('deployment.kubernetes.io/revision', nil)
-                  (rs_revision and (d_revision == rs_revision))
-                end
-                .sort_by do |_rs|
-                  Time.parse _rs['metadata']['creationTimestamp']
-                end.first
-            end
-
-            if rs
-              # Pod'ы связанные с активным ReplicaSet
-              rs_pods = app.deployment.kubernetes
-                .pod_list(labelSelector: labels.map{|k, v| "#{k}=#{v}"}.join(','))['items']
-                .select do |pod|
-                  Array(pod['metadata']['ownerReferences']).any? do |owner_reference|
-                    owner_reference['uid'] == rs['metadata']['uid']
-                  end
-                end
-
-              app.deployment.dapp.with_log_indent do
-                app.deployment.dapp.log_info("Pods:") if rs_pods.any?
-
-                rs_pods.each do |pod|
-                  app.deployment.dapp.with_log_indent do
-                    app.deployment.dapp.log_info("* #{pod['metadata']['name']}")
-
-                    known_events_by_pod[pod['metadata']['name']] ||= []
-                    pod_events = app.deployment.kubernetes
-                      .event_list(fieldSelector: "involvedObject.uid=#{pod['metadata']['uid']}")['items']
-                      .reject do |event|
-                        known_events_by_pod[pod['metadata']['name']].include? event['metadata']['uid']
-                      end
-
-                    if pod_events.any?
-                      pod_events.each do |event|
-                        app.deployment.dapp.with_log_indent do
-                          app.deployment.dapp.log_info("[#{event['metadata']['creationTimestamp']}] #{event['message']}")
-                        end
-                        known_events_by_pod[pod['metadata']['name']] << event['metadata']['uid']
-                      end
-                    end
-
-                    ready_condition = pod['status'].fetch('conditions', {}).find {|condition| condition['type'] == 'Ready'}
-                    next if (not ready_condition) or (ready_condition['status'] == 'True')
-
-                    if ready_condition['reason'] == 'ContainersNotReady'
-                      Array(pod['status']['containerStatuses']).each do |container_status|
-                        next if container_status['ready']
-
-                        waiting_reason = container_status.fetch('state', {}).fetch('waiting', {}).fetch('reason', nil)
-                        case waiting_reason
-                        when 'ImagePullBackOff', 'ErrImagePull'
-                          raise Error::Base,
-                            code: :image_not_found,
-                            data: {app: app.name,
-                                   pod_name: pod['metadata']['name'],
-                                   reason: container_status['state']['waiting']['reason'],
-                                   message: container_status['state']['waiting']['message']}
-                        when 'CrashLoopBackOff'
-                          raise Error::Base,
-                            code: :container_crash,
-                            data: {app: app.name,
-                                   pod_name: pod['metadata']['name'],
-                                   reason: container_status['state']['waiting']['reason'],
-                                   message: container_status['state']['waiting']['message']}
-                        end
-                      end
-                    else
-                      app.deployment.dapp.with_log_indent do
-                        app.deployment.dapp.log_warning("Unknown pod readiness condition reason '#{ready_condition['reason']}': #{ready_condition}")
-                      end
-                    end
-                  end # with_log_indent
-                end # rs_pods.each
-              end # with_log_indent
-            end
-
-            break if begin
-              d_revision and
-                d['spec']['replicas'] and
-                  d['status']['updatedReplicas'] and
-                    d['status']['availableReplicas'] and
-                      d['status']['readyReplicas'] and
-                        (d['status']['updatedReplicas'] >= d['spec']['replicas']) and
-                          (d['status']['availableReplicas'] >= d['spec']['replicas']) and
-                            (d['status']['readyReplicas'] >= d['spec']['replicas'])
-            end
-
-            sleep 1
-            d = app.deployment.kubernetes.deployment(d['metadata']['name'])
-          end
-        end
-      end
-
       def _field_value_for_log(value)
         value ? value : '-'
       end

data/lib/dapp/kube/cli/command/kube/deploy.rb

@@ -35,6 +35,12 @@ BANNER
              default: [],
              proc: proc { |v| composite_options(:helm_secret_values) << v }
 
+      option :timeout,
+             long: '--timeout INTEGER_SECONDS',
+             default: nil,
+             description: 'Default timeout to wait for resources to become ready, 300 seconds by default.',
+             proc: proc {|v| Integer(v)}
+
       def run(argv = ARGV)
         self.class.parse_options(self, argv)
         repo = self.class.required_argument(self, 'repo')

data/lib/dapp/kube/dapp/command/deploy.rb

@@ -13,27 +13,27 @@ module Dapp
             validate_repo_name!(repo)
             validate_tag_name!(image_version)
 
+            # TODO: Перенести код процесса выката в Helm::Manager
+
             with_kube_tmp_chart_dir do
               kube_copy_chart
               kube_helm_decode_secrets
               kube_generate_helm_chart_tpl
 
-              additional_values = [].tap do |options|
-                options.concat((kube_values_paths + kube_tmp_chart_secret_values_paths).map { |p| "--values #{p}" })
-              end
-
-              set_options = [].tap do |options|
-                options << "--set global.dapp.repo=#{repo}"
-                options << "--set global.dapp.image_version=#{image_version}"
-                options << "--set global.namespace=#{kube_namespace}"
-                options.concat(self.options[:helm_set_options].map { |opt| "--set #{opt}" })
-              end
-
-              hooks_jobs = kube_helm_hooks_jobs(additional_values, set_options)
-
-              kube_flush_hooks_jobs(hooks_jobs)
-
-              kube_run_deploy(additional_values, set_options, hooks_jobs: hooks_jobs)
+              release = Helm::Release.new(
+                self,
+                name: kube_release_name,
+                repo: repo,
+                image_version: image_version,
+                namespace: kube_namespace,
+                chart_path: kube_tmp_chart_path,
+                set: self.options[:helm_set_options],
+                values: [*kube_values_paths, *kube_tmp_chart_secret_values_paths],
+                deploy_timeout: self.options[:timeout] || 300
+              )
+
+              kube_flush_hooks_jobs(release)
+              kube_run_deploy(release)
             end
           end
 
@@ -94,34 +94,13 @@ module Dapp
             kube_tmp_chart_path('templates/_dapp_helpers.tpl').write(cont)
           end
 
-          def kube_flush_hooks_jobs(hooks_jobs)
-            return if (config_jobs_names = hooks_jobs.keys).empty?
-            config_jobs_names.select { |name| kube_job_list.include? name }.each do |name|
-              log_process("Delete hooks job `#{name}` for release #{kube_release_name} ", short: true) { kube_delete_job!(name) }
-            end
-          end
-
-          def kube_helm_hooks_jobs(additional_values, set_options)
-            generator = proc do |text|
-              text.split(/# Source.*|---/).reject {|c| c.strip.empty? }.map {|c| yaml_load(c) }.reduce({}) do |objects, c|
-                objects[c['kind']] ||= {}
-                objects[c['kind']][(c['metadata'] || {})['name']] = c
-                objects
+          def kube_flush_hooks_jobs(release)
+            release.hooks.values
+              .reject { |job| ['0', 'false'].include? job.annotations["dapp/recreate"].to_s }
+              .select { |job| kube_job_list.include? job.name }
+              .each do |job|
+                log_process("Delete hooks job `#{job.name}` for release #{release.name}", short: true) { kube_delete_job!(job.name) }
               end
-            end
-
-            args = [kube_release_name, kube_tmp_chart_path, additional_values, set_options, kube_helm_extra_options(dry_run: true)].flatten
-            output = shellout!("helm upgrade #{args.join(' ')}").stdout
-
-            manifest_start_index = output.lines.index("MANIFEST:\n") + 1
-            hook_start_index     = output.lines.index("HOOKS:\n") + 1
-            configs = generator.call(output.lines[hook_start_index..manifest_start_index-2].join)
-
-            (configs['Job'] || {}).reject do |_, c|
-              c['metadata'] ||= {}
-              c['metadata']['annotations'] ||= {}
-              c['metadata']['annotations']['helm.sh/resource-policy'] == 'keep'
-            end
           end
 
           def kube_job_list
@@ -136,14 +115,12 @@ module Dapp
             end
           end
 
-          def kube_run_deploy(additional_values, set_options, hooks_jobs: {})
-            log_process("Deploy release #{kube_release_name}") do
-              release_exists = shellout("helm status #{kube_release_name}").status.success?
-
-              hooks_jobs_by_type = hooks_jobs
-                .reduce({}) do |res, (job_name, job_spec)|
-                  job = Kubernetes::Client::Resource::Job.new(job_spec)
+          def kube_run_deploy(release)
+            log_process("Deploy release #{release.name}") do
+              release_exists = shellout("helm status #{release.name}").status.success?
 
+              watch_hooks_by_type = release.jobs.values
+                .reduce({}) do |res, job|
                   if job.annotations['dapp/watch-logs'].to_s == 'true'
                     job.annotations['helm.sh/hook'].to_s.split(',').each do |hook_type|
                       res[hook_type] ||= []
@@ -159,44 +136,42 @@ module Dapp
                   end
                 end
 
-              watch_jobs = if release_exists
-                hooks_jobs_by_type['pre-upgrade'].to_a + hooks_jobs_by_type['post-upgrade'].to_a
+              watch_hooks = if release_exists
+                watch_hooks_by_type['pre-upgrade'].to_a + watch_hooks_by_type['post-upgrade'].to_a
               else
-                hooks_jobs_by_type['pre-install'].to_a + hooks_jobs_by_type['post-install'].to_a
+                watch_hooks_by_type['pre-install'].to_a + watch_hooks_by_type['post-install'].to_a
               end
 
-              watch_thr = Thread.new do
-                watch_jobs.each {|job| Kubernetes::Manager::Job.new(self, job.name).watch_till_done!}
+              watch_hooks_thr = Thread.new do
+                watch_hooks.each {|job| Kubernetes::Manager::Job.new(self, job.name).watch_till_done!}
+                puts "DONE!"
               end
 
-              args = [kube_release_name, kube_tmp_chart_path, additional_values, set_options, kube_helm_extra_options].flatten
-              kubernetes.create_namespace!(kube_namespace) unless kubernetes.namespace?(kube_namespace)
-              shellout! "helm upgrade #{args.join(' ')}", verbose: true
+              deployment_managers = release.deployments.values
+                .map {|deployment| Kubernetes::Manager::Deployment.new(self, deployment.name)}
 
-              watch_thr.join
-            end
-          end
+              deployment_managers.each(&:before_deploy)
 
-          def kube_check_helm_chart!
-            raise Error::Command, code: :project_helm_chart_not_found, data: { path: kube_chart_path } unless kube_chart_path.exist?
-          end
+              release.deploy!
 
-          def kube_helm_extra_options(dry_run: dry_run?)
-            [].tap do |options|
-              options << "--namespace #{kube_namespace}"
-              options << '--install'
+              deployment_managers.each(&:after_deploy)
 
-              unless ['1', 'true'].include? ENV['DAPP_HELM_WAIT_DISABLED'].to_s
-                options << '--wait'
-                timeout = (ENV['DAPP_HELM_WAIT_TIMEOUT'] || 120).to_i
-                options << "--timeout #{timeout}"
+              begin
+                ::Timeout::timeout(self.options[:timeout] || 300) do
+                  watch_hooks_thr.join
+                  deployment_managers.each {|deployment_manager| deployment_manager.watch_till_ready!}
+                end
+              rescue ::Timeout::Error
+                watch_hooks_thr.kill if watch_hooks_thr.alive?
+                raise Error::Base, code: :deploy_timeout
               end
-
-              options << '--dry-run' if dry_run
-              options << '--debug'   if dry_run || log_verbose?
             end
           end
 
+          def kube_check_helm_chart!
+            raise Error::Command, code: :project_helm_chart_not_found, data: { path: kube_chart_path } unless kube_chart_path.exist?
+          end
+
           def kube_tmp_chart_secret_path(*path)
             kube_tmp_chart_path('decoded-secret', *path).tap { |p| p.parent.mkpath }
           end
@@ -223,6 +198,10 @@ module Dapp
           def kube_chart_secret_values_path
             kube_chart_path('secret-values.yaml').expand_path
           end
+
+          def kube_helm_manager
+            @kube_helm_manager ||= Helm::Manager.new(self)
+          end
         end
       end
     end

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

@@ -1,7 +1,11 @@
 module Dapp
   module Kube
     module Error
-      class Base < ::Dapp::Error::Base; end
+      class Base < ::Dapp::Error::Base
+        def initialize(net_status = {})
+          super({context: 'kube'}.merge(net_status))
+        end
+      end
     end
   end
 end

data/lib/dapp/kube/helm.rb

@@ -0,0 +1,5 @@
+module Dapp
+  module Kube
+    module Helm ; end
+  end # Kube
+end # Dapp

data/lib/dapp/kube/helm/release.rb

@@ -0,0 +1,120 @@
+module Dapp
+  module Kube
+    class Helm::Release
+      include Helper::YAML
+
+      attr_reader :dapp
+
+      attr_reader :name
+      attr_reader :repo
+      attr_reader :image_version
+      attr_reader :namespace
+      attr_reader :chart_path
+      attr_reader :set
+      attr_reader :values
+      attr_reader :deploy_timeout
+
+      def initialize(dapp,
+        name:, repo:, image_version:, namespace:, chart_path:,
+        set: [], values: [], deploy_timeout: nil)
+        @dapp = dapp
+
+        @name = name
+        @repo = repo
+        @image_version = image_version
+        @namespace = namespace
+        @chart_path = chart_path
+        @set = set
+        @values = values
+        @deploy_timeout = deploy_timeout
+      end
+
+      def jobs
+        (resources_specs['Job'] || {}).map do |name, spec|
+          [name, Kubernetes::Client::Resource::Job.new(spec)]
+        end.to_h
+      end
+
+      def hooks
+        jobs.select do |_, spec|
+          spec.annotations.key? "helm.sh/hook"
+        end
+      end
+
+      def deployments
+        (resources_specs['Deployment'] || {}).map do |name, spec|
+          [name, Kubernetes::Client::Resource::Deployment.new(spec)]
+        end.to_h
+      end
+
+      def deploy!
+        args = [
+          name, chart_path, additional_values,
+          set_options, extra_options
+        ].flatten
+
+        dapp.kubernetes.create_namespace!(namespace) unless dapp.kubernetes.namespace?(namespace)
+
+        dapp.shellout! "helm upgrade #{args.join(' ')}", verbose: true
+      end
+
+      protected
+
+      def evaluation_output
+        @evaluation_output ||= begin
+          args = [
+            name, chart_path, additional_values,
+            set_options, extra_options(dry_run: true)
+          ].flatten
+
+          dapp.shellout!("helm upgrade #{args.join(' ')}").stdout
+        end
+      end
+
+      def resources_specs
+        @resources_specs ||= {}.tap do |specs|
+          generator = proc do |text|
+            text.split(/# Source.*|---/).reject {|c| c.strip.empty? }.map {|c| yaml_load(c) }.each do |spec|
+              specs[spec['kind']] ||= {}
+              specs[spec['kind']][(spec['metadata'] || {})['name']] = spec
+            end
+          end
+
+          manifest_start_index = evaluation_output.lines.index("MANIFEST:\n") + 1
+          hook_start_index = evaluation_output.lines.index("HOOKS:\n") + 1
+          manifest_end_index = evaluation_output.lines.index("Release \"#{name}\" has been upgraded. Happy Helming!\n")
+
+          generator.call(evaluation_output.lines[hook_start_index..manifest_start_index-2].join)
+          generator.call(evaluation_output.lines[manifest_start_index..manifest_end_index-2].join)
+        end
+      end
+
+      def additional_values
+        [].tap do |options|
+          options.concat(values.map { |p| "--values #{p}" })
+        end
+      end
+
+      def set_options
+        [].tap do |options|
+          options << "--set global.dapp.repo=#{repo}"
+          options << "--set global.dapp.image_version=#{image_version}"
+          options << "--set global.namespace=#{namespace}"
+          options.concat(set.map { |opt| "--set #{opt}" })
+        end
+      end
+
+      def extra_options(dry_run: nil)
+        dry_run = dapp.dry_run? if dry_run.nil?
+
+        [].tap do |options|
+          options << "--namespace #{namespace}"
+          options << '--install'
+          options << '--dry-run' if dry_run
+          options << '--debug'   if dry_run || dapp.log_verbose?
+          options << "--timeout #{deploy_timeout}" if deploy_timeout
+        end
+      end
+    end # Helm::Release
+  end # Kube
+end # Dapp

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

@@ -8,12 +8,24 @@ module Dapp
           @spec = spec
         end
 
+        def metadata
+          spec.fetch('metadata', {})
+        end
+
         def name
-          spec.fetch('metadata', {})['name']
+          metadata['name']
+        end
+
+        def uid
+          metadata['uid']
         end
 
         def annotations
-          spec.fetch('metadata', {}).fetch('annotations', {})
+          metadata.fetch('annotations', {})
+        end
+
+        def status
+          spec.fetch('status', {})
         end
       end # Base
     end # Kubernetes::Client::Resource

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

@@ -0,0 +1,11 @@
+module Dapp
+  module Kube
+    module Kubernetes::Client::Resource
+      class Deployment < Base
+        def replicas
+          spec.fetch('spec', {}).fetch('replicas', nil)
+        end
+      end # Deployment
+    end # Kubernetes::Client::Resource
+  end # Kube
+end # Dapp

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

@@ -0,0 +1,8 @@
+module Dapp
+  module Kube
+    module Kubernetes::Client::Resource
+      class Event < Base
+      end # Event
+    end # Kubernetes::Client::Resource
+  end # Kube
+end # Dapp

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

@@ -15,8 +15,7 @@ module Dapp
         end
 
         def container_state(container_name)
-          container_status = spec
-            .fetch('status', {})
+          container_status = status
             .fetch('containerStatuses', [])
             .find {|cs| cs['name'] == container_name}
 
@@ -29,7 +28,7 @@ module Dapp
         end
 
         def phase
-          spec.fetch('status', {}).fetch('phase', nil)
+          status.fetch('phase', nil)
         end
 
         def containers_names

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

@@ -0,0 +1,8 @@
+module Dapp
+  module Kube
+    module Kubernetes::Client::Resource
+      class Replicaset < Base
+      end # Replicaset
+    end # Kubernetes::Client::Resource
+  end # Kube
+end # Dapp

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

@@ -40,6 +40,7 @@ module Dapp
 
               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]
@@ -47,14 +48,14 @@ module Dapp
                 .reject {|timestamp, _| @processed_log_timestamps.include? timestamp}
 
               chunk_lines_by_time.each do |timestamp, data|
-                puts data
+                dapp.log("[#{timestamp}] #{data}")
                 @processed_log_timestamps.add timestamp
               end
 
               if container_state == 'terminated'
                 failed = (container_state_data['exitCode'].to_i != 0)
 
-                warn("".tap do |msg|
+                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

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

@@ -0,0 +1,202 @@
+module Dapp
+  module Kube
+    module Kubernetes::Manager
+      class Deployment < Base
+        # NOTICE: @revision_before_deploy на данный момент выводится на экран как информация для дебага.
+        # NOTICE: deployment.kubernetes.io/revision не меняется при изменении количества реплик, поэтому
+        # NOTICE: критерий ожидания по изменению ревизии не верен.
+        # NOTICE: Однако, при обновлении deployment ревизия сбрасывается и ожидание переустановки этой ревизии
+        # NOTICE: является одним из критериев завершения ожидания на данный момент.
+
+        def before_deploy
+          if dapp.kubernetes.deployment? name
+            d = Kubernetes::Client::Resource::Deployment.new(dapp.kubernetes.deployment(name))
+
+            @revision_before_deploy = d.annotations['deployment.kubernetes.io/revision']
+
+            unless @revision_before_deploy.nil?
+              new_spec = Marshal.load(Marshal.dump(d.spec))
+              new_spec.delete('status')
+              new_spec.fetch('metadata', {}).fetch('annotations', {}).delete('deployment.kubernetes.io/revision')
+
+              @deployment_before_deploy = Kubernetes::Client::Resource::Deployment.new(dapp.kubernetes.replace_deployment!(name, new_spec))
+            end
+          end
+        end
+
+        def after_deploy
+          @deployed_at = Time.now
+        end
+
+        def watch_till_ready!
+          dapp.log_process("Watch deployment '#{name}' till ready") do
+            known_events_by_pod = {}
+            known_log_timestamps_by_pod_and_container = {}
+
+            d = @deployment_before_deploy || Kubernetes::Client::Resource::Deployment.new(dapp.kubernetes.deployment(name))
+
+            loop do
+              d_revision = d.annotations['deployment.kubernetes.io/revision']
+
+              dapp.log_step("[#{Time.now}] Poll deployment '#{d.name}' status")
+              dapp.with_log_indent do
+                dapp.log_info("Target replicas: #{_field_value_for_log(d.replicas)}")
+                dapp.log_info("Updated replicas: #{_field_value_for_log(d.status['updatedReplicas'])} / #{_field_value_for_log(d.replicas)}")
+                dapp.log_info("Available replicas: #{_field_value_for_log(d.status['availableReplicas'])} / #{_field_value_for_log(d.replicas)}")
+                dapp.log_info("Ready replicas: #{_field_value_for_log(d.status['readyReplicas'])} / #{_field_value_for_log(d.replicas)}")
+                dapp.log_info("Old deployment.kubernetes.io/revision: #{_field_value_for_log(@revision_before_deploy)}")
+                dapp.log_info("Current deployment.kubernetes.io/revision: #{_field_value_for_log(d_revision)}")
+              end
+
+              rs = nil
+              if d_revision
+                # Находим актуальный, текущий ReplicaSet.
+                # Если такая ситуация, когда есть несколько подходящих по revision ReplicaSet, то берем старейший по дате создания.
+                # Также делает kubectl: https://github.com/kubernetes/kubernetes/blob/d86a01570ba243e8d75057415113a0ff4d68c96b/pkg/controller/deployment/util/deployment_util.go#L664
+                rs = dapp.kubernetes.replicaset_list['items']
+                  .map {|spec| Kubernetes::Client::Resource::Replicaset.new(spec)}
+                  .select do |_rs|
+                    Array(_rs.metadata['ownerReferences']).any? do |owner_reference|
+                      owner_reference['uid'] == d.metadata['uid']
+                    end
+                  end
+                  .select do |_rs|
+                    rs_revision = _rs.annotations['deployment.kubernetes.io/revision']
+                    (rs_revision and (d_revision == rs_revision))
+                  end
+                  .sort_by do |_rs|
+                    if creation_timestamp = _rs.metadata['creationTimestamp']
+                      Time.parse(creation_timestamp)
+                    else
+                      Time.now
+                    end
+                  end.first
+              end
+
+              if rs
+                # Pod'ы связанные с активным ReplicaSet
+                rs_pods = dapp.kubernetes.pod_list['items']
+                  .map {|spec| Kubernetes::Client::Resource::Pod.new(spec)}
+                  .select do |pod|
+                    Array(pod.metadata['ownerReferences']).any? do |owner_reference|
+                      owner_reference['uid'] == rs.metadata['uid']
+                    end
+                  end
+
+                dapp.with_log_indent do
+                  dapp.log_step("Pods:") if rs_pods.any?
+
+                  rs_pods.each do |pod|
+                    dapp.with_log_indent do
+                      dapp.log_step(pod.name)
+
+                      known_events_by_pod[pod.name] ||= []
+                      pod_events = dapp.kubernetes
+                        .event_list(fieldSelector: "involvedObject.uid=#{pod.uid}")['items']
+                        .map {|spec| Kubernetes::Client::Resource::Event.new(spec)}
+                        .reject do |event|
+                          known_events_by_pod[pod.name].include? event.uid
+                        end
+
+                      if pod_events.any?
+                        dapp.with_log_indent do
+                          dapp.log_step("Last events:")
+                          pod_events.each do |event|
+                            dapp.with_log_indent do
+                              dapp.log_info("[#{event.metadata['creationTimestamp']}] #{event.spec['message']}")
+                            end
+                            known_events_by_pod[pod.name] << event.uid
+                          end
+                        end
+                      end
+
+                      dapp.with_log_indent do
+                        pod.containers_names.each do |container_name|
+                          next if pod.container_state(name).first == 'waiting'
+
+                          known_log_timestamps_by_pod_and_container[pod.name] ||= {}
+                          known_log_timestamps_by_pod_and_container[pod.name][container_name] ||= Set.new
+
+                          since_time = nil
+                          since_time = @deployed_at.utc.iso8601(9) if @deployed_at
+
+                          log_lines_by_time = dapp.kubernetes.pod_log(pod.name, container: container_name, timestamps: true, sinceTime: since_time)
+                            .lines.map(&:strip)
+                            .map {|line|
+                              timestamp, _, data = line.partition(' ')
+                              unless known_log_timestamps_by_pod_and_container[pod.name][container_name].include? timestamp
+                                known_log_timestamps_by_pod_and_container[pod.name][container_name].add timestamp
+                                [timestamp, data]
+                              end
+                            }.compact
+
+                          if log_lines_by_time.any?
+                            dapp.log_step("Last container '#{container_name}' log:")
+                            dapp.with_log_indent do
+                              log_lines_by_time.each do |timestamp, line|
+                                dapp.log("[#{timestamp}] #{line}")
+                              end
+                            end
+                          end
+                        end
+                      end
+
+                      ready_condition = pod.status.fetch('conditions', {}).find {|condition| condition['type'] == 'Ready'}
+                      next if (not ready_condition) or (ready_condition['status'] == 'True')
+
+                      if ready_condition['reason'] == 'ContainersNotReady'
+                        Array(pod.status['containerStatuses']).each do |container_status|
+                          next if container_status['ready']
+
+                          waiting_reason = container_status.fetch('state', {}).fetch('waiting', {}).fetch('reason', nil)
+                          case waiting_reason
+                          when 'ImagePullBackOff', 'ErrImagePull'
+                            raise Error::Base,
+                              code: :image_not_found,
+                              data: {pod_name: pod.name,
+                                     reason: waiting_reason,
+                                     message: container_status['state']['waiting']['message']}
+                          when 'CrashLoopBackOff'
+                            raise Error::Base,
+                              code: :container_crash,
+                              data: {pod_name: pod.name,
+                                     reason: waiting_reason,
+                                     message: container_status['state']['waiting']['message']}
+                          end
+                        end
+                      else
+                        dapp.with_log_indent do
+                          dapp.log_warning("Unknown pod readiness condition reason '#{ready_condition['reason']}': #{ready_condition}")
+                        end
+                      end
+                    end # with_log_indent
+                  end # rs_pods.each
+                end # with_log_indent
+              end
+
+              break if begin
+                (d_revision and
+                  d.replicas and
+                    d.status['updatedReplicas'] and
+                      d.status['availableReplicas'] and
+                        d.status['readyReplicas'] and
+                          (d.status['updatedReplicas'] >= d.replicas) and
+                            (d.status['availableReplicas'] >= d.replicas) and
+                              (d.status['readyReplicas'] >= d.replicas))
+              end
+
+              sleep 5
+              d = Kubernetes::Client::Resource::Deployment.new(dapp.kubernetes.deployment(d.name))
+            end
+          end
+        end
+
+        private
+
+        def _field_value_for_log(value)
+          value ? value : '-'
+        end
+      end # Deployment
+    end # Kubernetes::Manager
+  end # Kube
+end # Dapp

data/lib/dapp/version.rb

@@ -1,4 +1,4 @@
 module Dapp
-  VERSION = '0.13.12'.freeze
+  VERSION = '0.13.13'.freeze
   BUILD_CACHE_VERSION = 15
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dapp
 version: !ruby/object:Gem::Version
-  version: 0.13.12
+  version: 0.13.13
 platform: ruby
 authors:
 - Dmitry Stolyarov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-01 00:00:00.000000000 Z
+date: 2017-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mixlib-shellout
@@ -647,14 +647,20 @@ files:
 - lib/dapp/kube/error/base.rb
 - lib/dapp/kube/error/command.rb
 - lib/dapp/kube/error/kubernetes.rb
+- lib/dapp/kube/helm.rb
+- lib/dapp/kube/helm/release.rb
 - lib/dapp/kube/kubernetes.rb
 - lib/dapp/kube/kubernetes/client.rb
 - lib/dapp/kube/kubernetes/client/error.rb
 - lib/dapp/kube/kubernetes/client/resource/base.rb
+- lib/dapp/kube/kubernetes/client/resource/deployment.rb
+- lib/dapp/kube/kubernetes/client/resource/event.rb
 - lib/dapp/kube/kubernetes/client/resource/job.rb
 - lib/dapp/kube/kubernetes/client/resource/pod.rb
+- lib/dapp/kube/kubernetes/client/resource/replicaset.rb
 - lib/dapp/kube/kubernetes/manager/base.rb
 - lib/dapp/kube/kubernetes/manager/container.rb
+- lib/dapp/kube/kubernetes/manager/deployment.rb
 - lib/dapp/kube/kubernetes/manager/job.rb
 - lib/dapp/kube/kubernetes/manager/pod.rb
 - lib/dapp/kube/secret.rb