dapp 0.22.6 → 0.22.7

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

@@ -23,7 +23,9 @@ module Dapp
               .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) }
+                log_process("Delete hooks job `#{job.name}` for release #{release.name}", short: true) do
+                  kube_delete_job!(job.name) unless dry_run?
+                end
               end
           end
 
@@ -66,8 +68,11 @@ module Dapp
                 watch_hooks_by_type['pre-install'].to_a + watch_hooks_by_type['post-install'].to_a
               end
 
-              watch_hooks_thr = Thread.new do
-                watch_hooks.each {|job| Kubernetes::Manager::Job.new(self, job.name).watch_till_done!}
+              watch_hooks_thr = nil
+              unless dry_run?
+                watch_hooks_thr = Thread.new do
+                  watch_hooks.each {|job| Kubernetes::Manager::Job.new(self, job.name).watch_till_done!}
+                end
               end
 
               deployment_managers = release.deployments.values
@@ -79,14 +84,16 @@ module Dapp
 
               deployment_managers.each(&:after_deploy)
 
-              watch_hooks_thr.kill if watch_hooks_thr.alive?
+              watch_hooks_thr.kill if !dry_run? && watch_hooks_thr && watch_hooks_thr.alive?
 
-              begin
-                ::Timeout::timeout(self.options[:timeout] || 300) do
-                  deployment_managers.each {|deployment_manager| deployment_manager.watch_till_ready!}
+              unless dry_run?
+                begin
+                  ::Timeout::timeout(self.options[:timeout] || 300) do
+                    deployment_managers.each {|deployment_manager| deployment_manager.watch_till_ready!}
+                  end
+                rescue ::Timeout::Error
+                  raise ::Dapp::Error::Command, code: :kube_deploy_timeout
                 end
-              rescue ::Timeout::Error
-                raise Kube::Error::Base, code: :deploy_timeout
               end
             end
           end

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

@@ -16,7 +16,7 @@ module Dapp
 
           def kube_check_helm_release!
             pr = shellout("helm list | grep #{kube_release_name}")
-            raise Error::Command, code: :helm_release_not_exist, data: { name: kube_release_name } if pr.status == 1 || pr.stdout.empty?
+            raise ::Dapp::Error::Command, code: :helm_release_not_exist, data: { name: kube_release_name } if pr.status == 1 || pr.stdout.empty?
           end
         end
       end

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

@@ -8,7 +8,7 @@ module Dapp
             chart_spec = yaml_load_file(chart_yaml_path)
 
             if chart_spec["name"].nil? || chart_spec["name"].empty?
-              raise Error::Command, code: :bad_helm_chart_spec_name, data: { name: chart_spec["name"], path: chart_yaml_path, raw_spec: chart_yaml_path.read.strip }
+              raise ::Dapp::Error::Command, code: :no_helm_chart_spec_name, data: { name: chart_spec["name"], path: chart_yaml_path, raw_spec: chart_yaml_path.read.strip }
             end
 
             chart_spec["name"]
@@ -32,8 +32,7 @@ module Dapp
 
             repo = option_repo
 
-            docker_tag = options[:docker_tag]
-            docker_tag = consistent_uniq_slugify(docker_tag) if docker_tag
+            docker_tag = option_tags.first
 
             with_kube_tmp_lint_chart_dir do
               kube_copy_chart
@@ -60,13 +59,8 @@ module Dapp
                 end
               end
 
-              all_values['global'] = {
-                'namespace' => kube_namespace,
-                'dapp' => {
-                  'repo' => repo,
-                  'docker_tag' => docker_tag
-                }
-              }
+              service_values = Helm::Values.service_values_hash(self, repo, kube_namespace, docker_tag, fake: true)
+              all_values = all_values.in_depth_merge service_values
 
               kube_chart_path_for_helm.join("values.yaml").write YAML.dump(all_values)
 

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

@@ -3,12 +3,6 @@ module Dapp
     module Dapp
       module Command
         module MinikubeSetup
-          class MinikubeSetupError < Error::Command
-            def initialize(**net_status)
-              super(**net_status, context: :minikube_setup)
-            end
-          end
-
           def kube_minikube_setup
             _minikube_restart_minikube
 
@@ -34,7 +28,7 @@ module Dapp
 
           def _minikube_restart_minikube
             log_process("Restart minikube") do
-              raise MinikubeSetupError, code: :minikube_not_found if shellout('which minikube').exitstatus == 1
+              raise ::Dapp::Error::Command, code: :minikube_not_found if shellout('which minikube').exitstatus == 1
 
               Process.fork do
                 _minikube_set_original_sudo_caller_process_user!
@@ -50,7 +44,7 @@ module Dapp
               end
 
               _, status = Process.wait2
-              raise MinikubeSetupError, code: :cannot_restart_minikube unless status.success?
+              raise ::Dapp::Error::Command, code: :cannot_restart_minikube unless status.success?
             end
           end
 
@@ -97,7 +91,7 @@ module Dapp
             rescue Errno::ESRCH
               daemon_ok = false
             end
-            raise MinikubeSetupError, code: :"#{name}_daemon_failed" unless daemon_ok
+            raise ::Dapp::Error::Command, code: :"#{name}_daemon_failed" unless daemon_ok
           end
 
           def _minikube_run_minikube_persisted_storage_daemon
@@ -127,7 +121,7 @@ module Dapp
                 sleep 1
               end
 
-              raise MinikubeSetupError, code: :minikube_readiness_timeout
+              raise ::Dapp::Error::Command, code: :minikube_readiness_timeout
             end
           end
 
@@ -145,7 +139,7 @@ module Dapp
                     end
                     sleep 1
                   end
-                  raise MinikubeSetupError, code: :registry_replicationcontroller_shutdown_failed unless shutdown_ok
+                  raise ::Dapp::Error::Command, code: :registry_replicationcontroller_shutdown_failed unless shutdown_ok
                 end
 
                 _minikube_kubernetes.delete_pods! labelSelector: 'k8s-app=kube-registry'
@@ -157,7 +151,7 @@ module Dapp
                   end
                   sleep 1
                 end
-                raise MinikubeSetupError, code: :registry_pod_shutdown_failed unless shutdown_ok
+                raise ::Dapp::Error::Command, code: :registry_pod_shutdown_failed unless shutdown_ok
 
                 if _minikube_kubernetes.service? _minikube_registry_service_spec['metadata']['name']
                   _minikube_kubernetes.delete_service! _minikube_registry_service_spec['metadata']['name']
@@ -170,7 +164,7 @@ module Dapp
                     end
                     sleep 1
                   end
-                  raise MinikubeSetupError, code: :registry_service_shutdown_failed unless shutdown_ok
+                  raise ::Dapp::Error::Command, code: :registry_service_shutdown_failed unless shutdown_ok
                 end
 
                 if _minikube_kubernetes.pod? _minikube_registry_proxy_pod_spec['metadata']['name']
@@ -184,7 +178,7 @@ module Dapp
                     end
                     sleep 1
                   end
-                  raise MinikubeSetupError, code: :registry_proxy_pod_shutdown_failed unless shutdown_ok
+                  raise ::Dapp::Error::Command, code: :registry_proxy_pod_shutdown_failed unless shutdown_ok
                 end
 
                 _minikube_kubernetes.create_replicationcontroller!(_minikube_registry_replicationcontroller_spec)
@@ -199,7 +193,7 @@ module Dapp
                   end
                   sleep 1
                 end
-                raise MinikubeSetupError, code: :registry_pod_not_ok unless registry_pod_ok
+                raise ::Dapp::Error::Command, code: :registry_pod_not_ok unless registry_pod_ok
 
                 _minikube_kubernetes.create_service!(_minikube_registry_service_spec)
                 registry_service_ok = false
@@ -210,7 +204,7 @@ module Dapp
                   end
                   sleep 1
                 end
-                raise MinikubeSetupError, code: :registry_service_not_ok unless registry_service_ok
+                raise ::Dapp::Error::Command, code: :registry_service_not_ok unless registry_service_ok
 
                 _minikube_kubernetes.create_pod! _minikube_registry_proxy_pod_spec
                 registry_proxy_pod_ok = false
@@ -224,7 +218,7 @@ module Dapp
                   end
                   sleep 1
                 end
-                raise MinikubeSetupError, code: :registry_proxy_pod_not_ok unless registry_proxy_pod_ok
+                raise ::Dapp::Error::Command, code: :registry_proxy_pod_not_ok unless registry_proxy_pod_ok
               end
             end
           end
@@ -237,7 +231,7 @@ module Dapp
               rescue Errno::ECONNREFUSED
                 false
               end
-              raise MinikubeSetupError, code: :registry_port_in_use, data: {host: 'localhost', port: 5000} if registry_port_in_use
+              raise ::Dapp::Error::Command, code: :registry_port_in_use, data: {host: 'localhost', port: 5000} if registry_port_in_use
 
               _minikube_run_daemon(:registry_forwarder) do
                 STDIN.reopen '/dev/null'

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

@@ -43,7 +43,7 @@ module Dapp
 
                   IO.binwrite(file_path, "#{encoded_data}\n")
                   break
-                rescue ::Dapp::Error::Base => e
+                rescue ::Dapp::Error::Default => e
                   log_warning(Helper::NetStatus.message(e))
                   print 'Do you want to change file (Y/n)?'
                   response = $stdin.getch.tap { print "\n" }
@@ -56,7 +56,7 @@ module Dapp
           def kube_secret_editor
             return ENV['EDITOR'] unless ENV['EDITOR'].nil?
             %w(vim vi nano).each { |editor| return editor unless shellout("which #{editor}").exitstatus.nonzero? }
-            raise Error::Command, code: :editor_not_found
+            raise ::Dapp::Error::Command, code: :editor_not_found
           end
 
           private

data/lib/dapp/kube/error/{command.rb → default.rb}

@@ -1,7 +1,7 @@
 module Dapp
   module Kube
     module Error
-      class Command < Base; end
+      class Default < ::Dapp::Error::Default; end
     end
   end
 end

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

@@ -1,7 +1,7 @@
 module Dapp
   module Kube
     module Error
-      class Kubernetes < Base; end
+      class Kubernetes < Default; end
     end
   end
 end

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

@@ -123,40 +123,10 @@ module Dapp
 
       def set_options(without_registry: false)
         [].tap do |options|
-          options.concat(set.map { |opt| "--set #{opt}" })
-          options << "--set global.dapp.repo=#{repo}"
-          options << "--set global.dapp.docker_tag=#{docker_tag}"
-
-          if dapp.nameless_dimg?
-            options << "--set global.dapp.docker_image=#{repo}:#{docker_tag}"
-            if self.without_registry || without_registry
-              options << "--set global.dapp.docker_image_id=\\\"-\\\""
-            else
-              options << "--set global.dapp.docker_image_id=#{dimg_registry.image_id(docker_tag, nil)}"
-            end
-          else
-            dapp.dimgs_names.each do |dimg_name|
-              options << "--set global.dapp.docker_image.#{dimg_name}=#{repo}/#{dimg_name}:#{docker_tag}"
-              if self.without_registry || without_registry
-                options << "--set global.dapp.docker_image_id.#{dimg_name}=\\\"-\\\""
-              else
-                options << "--set global.dapp.docker_image_id.#{dimg_name}=#{dimg_registry.image_id(docker_tag, dimg_name)}"
-              end
-            end
-          end
+          options.concat set.map {|opt| "--set #{opt}"}
 
-          is_branch = if ENV["CI_COMMIT_TAG"]
-            false
-          elsif ENV["CI_COMMIT_REF_NAME"]
-            true
-          elsif dapp.git_path and dapp.git_local_repo.branch != "HEAD"
-            true
-          else
-            false
-          end
-          options << "--set global.dapp.is_branch=#{is_branch}"
-
-          options << "--set global.namespace=#{namespace}"
+          service_values = Helm::Values.service_values(dapp, repo, namespace, docker_tag, without_registry: self.without_registry || without_registry)
+          options.concat service_values.to_set_options
         end
       end
 
@@ -171,6 +141,10 @@ module Dapp
           options << "--timeout #{deploy_timeout}" if deploy_timeout
         end
       end
+
+      class << self
+
+      end # << self
     end # Helm::Release
   end # Kube
 end # Dapp

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

@@ -0,0 +1,140 @@
+module Dapp
+  module Kube
+    class Helm::Values
+      TEMPLATE_EMPTY_VALUE = "\\\"-\\\""
+
+      class << self
+        def service_values(*a, &b)
+          self.new(service_values_hash(*a, &b))
+        end
+
+        def service_values_hash(dapp, repo, namespace, docker_tag, fake: false, without_registry: false)
+          res = {
+            "global" => {
+              "namespace" => namespace,
+              "dapp" => {
+                "name" => dapp.name,
+                "repo" => repo,
+                "docker_tag" => docker_tag,
+              }
+            }
+          }
+
+          ci_info = {
+            "is_tag" => false,
+            "is_branch" => false,
+            "branch" => TEMPLATE_EMPTY_VALUE,
+            "tag" => TEMPLATE_EMPTY_VALUE,
+            "ref" => TEMPLATE_EMPTY_VALUE
+          }
+          res["global"]["dapp"]["ci"] = ci_info
+
+          if fake
+          elsif ENV["CI_COMMIT_TAG"]
+            ci_info["tag"] = ci_info["ref"] = ENV["CI_COMMIT_TAG"]
+            ci_info["is_tag"] = true
+          elsif ENV["CI_COMMIT_REF_NAME"]
+            ci_info["branch"] = ci_info["ref"] = ENV["CI_COMMIT_REF_NAME"]
+            ci_info["is_branch"] = true
+          elsif dapp.git_path and dapp.git_local_repo.branch != "HEAD"
+            ci_info["branch"] = ci_info["ref"] = dapp.git_local_repo.branch
+            ci_info["is_branch"] = true
+          elsif dapp.git_path
+            git = dapp.git_local_repo.send(:git)
+
+            tagref = git.references.find do |r|
+              if r.name.start_with?("refs/tags/")
+                if r.target.is_a? Rugged::Tag::Annotation
+                  r.target.target_id == git.head.target_id
+                else
+                  r.target_id == git.head.target_id
+                end
+              end
+            end
+
+            if tagref
+              tag = tagref.name.partition("refs/tags/").last
+            else
+              tag = git.head.target_id
+            end
+
+            ci_info["tag"] = ci_info["ref"] = tag
+            ci_info["is_tag"] = true
+          end
+
+          dimgs = dapp.build_configs.map do |config|
+            ::Dapp::Dimg::Dimg.new(config: config, dapp: dapp, ignore_git_fetch: true)
+          end.uniq do |dimg|
+            dimg.config._name
+          end
+
+          dimgs.each do |dimg|
+            dimg_data = {}
+            if dimg.config._name
+              res["global"]["dapp"]["is_nameless_dimg"] = false
+              res["global"]["dapp"]["dimg"] ||= {}
+              res["global"]["dapp"]["dimg"][dimg.config._name] = dimg_data
+            else
+              res["global"]["dapp"]["is_nameless_dimg"] = true
+              res["global"]["dapp"]["dimg"] = dimg_data
+            end
+
+            dimg_labels = {}
+            docker_image_id = TEMPLATE_EMPTY_VALUE
+            unless fake || without_registry
+              dimg_labels = dapp.dimg_registry(repo).image_labels(docker_tag, dimg.config._name)
+              docker_image_id = dapp.dimg_registry(repo).image_id(docker_tag, dimg.config._name)
+            end
+
+            dimg_data["docker_image"] = [[repo, dimg.config._name].compact.join("/"), docker_tag].join(":")
+            dimg_data["docker_image_id"] = docker_image_id
+
+            [*dimg.local_git_artifacts, *dimg.remote_git_artifacts].each do |ga|
+              if ga.as
+                commit_id = dimg_labels[dapp.dimgstage_g_a_commit_label(ga.paramshash)] || TEMPLATE_EMPTY_VALUE
+
+                dimg_data["git"] ||= {}
+                dimg_data["git"][ga.as] ||= {}
+                dimg_data["git"][ga.as]["commit_id"] = commit_id
+              end
+            end
+          end
+
+          res
+        end
+      end
+
+      attr_reader :data
+
+      def initialize(data={})
+        @data = data
+      end
+
+      def as_set_options
+        options = {}
+
+        queue = [[nil, data]]
+
+        loop do
+          option_key, hash = queue.shift
+          break unless hash
+
+          hash.each do |k, v|
+            new_option_key = [option_key, k].compact.join(".")
+            if v.is_a? Hash
+              queue << [new_option_key, v]
+            else
+              options[new_option_key] = v
+            end
+          end
+        end
+
+        options
+      end
+
+      def to_set_options
+        as_set_options.map {|k, v| "--set #{k}=#{v}"}
+      end
+    end # Helm::ServiceValues
+  end # Kube
+end # Dapp

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

@@ -150,15 +150,14 @@ module Dapp
           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
-            else
-              err_data[:response_raw_body] = response.body
             end
             err_data[:request_parameters] = request_parameters
 
             if response.status.to_s.start_with? '5'
-              raise Error::Base, code: :server_error, data: err_data
+              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'
@@ -177,8 +176,8 @@ module Dapp
             Excon.new(kube_cluster_config['cluster']['server'], **kube_server_options(excon_parameters)).tap(&:get)
           rescue Excon::Error::Socket => err
             raise Error::ConnectionRefused,
-              code: :kube_server_connection_refused,
-              data: { kube_cluster_config: kube_cluster_config, kube_user_config: kube_user_config, error: err.message }
+                  code: :server_connection_refused,
+                  data: { kube_cluster_config: kube_cluster_config, kube_user_config: kube_user_config, error: err.message }
           end
 
           return yield connection
@@ -217,7 +216,7 @@ module Dapp
         def kube_user_config
           @kube_user_config ||= begin
             kube_user_config = self.class.kube_user_config(kube_config, kube_context_config['context']['user'])
-            raise Error::BadConfig, code: :kube_user_not_found, data: {context: kube_context_config} if kube_user_config.nil?
+            raise Error::BadConfig, code: :user_config_not_found, data: {config_path: self.class.kube_config_path, context: kube_context_config, user: kube_context_config['context']['user']} if kube_user_config.nil?
             kube_user_config
           end
         end
@@ -225,7 +224,7 @@ module Dapp
         def kube_cluster_config
           @kube_cluster_config ||= begin
             kube_cluster_config = self.class.kube_cluster_config(kube_config, kube_context_config['context']['cluster'])
-            raise Error::BadConfig, code: :kube_cluster_not_found, data: {context: kube_context_config} if kube_cluster_config.nil?
+            raise Error::BadConfig, code: :cluster_config_not_found, data: {config_path: self.class.kube_config_path, context: kube_context_config, cluster: kube_context_config['context']['cluster']} if kube_cluster_config.nil?
             kube_cluster_config
           end
         end
@@ -234,7 +233,7 @@ module Dapp
           @kube_context_config ||= begin
             context_name = self.class.kube_context_name(kube_config)
             kube_context_config = self.class.kube_context_config(kube_config, context_name)
-            raise Error::BadConfig, code: :kube_context_not_found, data: {context_name: context_name} if kube_context_config.nil?
+            raise Error::BadConfig, code: :config_context_not_found, data: {config_path: self.class.kube_config_path, config: kube_config, context_name: context_name} if kube_context_config.nil?
             kube_context_config
           end
         end
@@ -242,7 +241,7 @@ module Dapp
         def kube_config
           @kube_config ||= begin
             kube_config = self.class.kube_config(self.class.kube_config_path)
-            raise Error::Base, code: :kube_config_not_found, data: { path: self.class.kube_config_path } if kube_config.nil?
+            raise Error::BadConfig, code: :config_not_found, data: { config_path: self.class.kube_config_path } if kube_config.nil?
             kube_config
           end
         end
@@ -260,7 +259,7 @@ module Dapp
 
           def kube_context_name(kube_config)
             kube_config['current-context'] || begin
-              if context = kube_config.fetch('contexts', []).first
+              if (context = kube_config.fetch('contexts', []).first)
                 warn "[WARN] .kube/config current-context is not set, using context '#{context['name']}'"
                 context['name']
               end