dapp 0.24.3 → 0.24.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 882b3acc8506bb005b8bf2a68aa9d1ac3e0cb432
-  data.tar.gz: b40f3e4feda32bc080ed2ba8e6e5316a5dff9d6f
+  metadata.gz: c9a285aead0a2e57006e54a0839ab32cf4170529
+  data.tar.gz: cd58972b2de67689e2173bffe9524a0623e79bc1
 SHA512:
-  metadata.gz: de722da958bc9b7610cd54f87d2c0b6362ed0828f7a086b9bb707f0f7d83b373e39eaa995dd6a603232c1c2aaf086f25b81cc881f18d8e6412a26a5334e8bf37
-  data.tar.gz: 4ddc1ed3725f9c7434c3bd1fd6fd85a665dec825001188a2f8314919fa8a386af6934241de2d82abac07e9cb2ab7192ec052565b3dc9f6fab0aceccb4eecd08e
+  metadata.gz: 9dbb053e622ce8ac204b9529dbf2c1ca266b22a4f46fec3736963861b5e74148ff19f423e297c1a3a9d0fd44afeeb787c3a448978ab2d0219273a23448eca36f
+  data.tar.gz: f15547e0e17c93ba3e39ec915a1413b6445392212c9779333aa9d6742888b86d1291ee6d4be3f830dc79a21fe7af88001b32a428fbf64111da2d58eba3842772

data/config/en/net_status.yml

@@ -44,6 +44,7 @@ en:
       expected_only_one_tag: 'Expected only one tag (`%{tags}`)!'
       kube_deploy_timeout: "Deploy timeout!"
       kube_connect_timeout: "Connect timeout when connecting to kube API."
+      kube_helm_failed: "Helm failed: %{output}"
     dapp:
       no_such_dimg: "No such dimg: `%{dimgs_patterns}`!"
       no_such_app: "No such app: `%{apps_patterns}`!"
@@ -80,7 +81,7 @@ en:
       stage_artifact_double_associate: "Can't use `%{stage}` stage for artifact; already used in `%{conflict_stage}` stage!"
       stage_artifact_not_supported_associated_stage: "Bad artifact stage `%{stage}`!"
       git_artifact_remote_branch_with_commit: "Remote git repo: use `commit` or `branch` directive!"
-      artifact_conflict: "Conflict between artifacts paths!"
+      artifact_conflict: "Conflict between artifacts!\n\n%{dappfile_context}"
       scratch_unsupported_directive: "Scratch dimg has unsupported directive `%{directive}`!"
       scratch_artifact_required: "Scratch dimg without artifacts!"
       scratch_artifact_associated: "Scratch artifact can't be associated: not expected `before`/`after` attribute!"
@@ -115,7 +116,7 @@ en:
     rugged:
       git_repository_reference_error: "Git repo `%{name}`: %{message}!"
       rugged_remote_error: "Remote git repo `%{url}`: `%{message}`!"
-      local_git_repository_does_not_exist: "Local git repo: doesn't exist!"
+      local_git_repository_does_not_exist: "Local git repo (`%{path}`): doesn't exist!"
       commit_not_found_in_local_git_repository: "Local git repo: commit `%{commit}` not found!\nIf commit has been rebased: run command `dapp dimg stages cleanup local --improper-git-commit`!"
       commit_not_found_in_remote_git_repository: "Remote git repo `%{url}`: commit `%{commit}` not found!\nIf commit has been rebased: run command `dapp dimg stages cleanup local --improper-git-commit`!"
       branch_not_exist_in_remote_git_repository: "Remote git repo `%{url}`: branch `%{branch}` not exist!"
@@ -136,6 +137,8 @@ en:
       server_connection_refused: "Kube server `%{url}` connection refused: %{error}"
       server_error: "Kube respond with server error code %{response_http_status}, request parameters: `%{request_parameters}`, response: `%{response_raw_body}`"
       container_stuck: "Pod's `%{pod_name}` container `%{container_name}` stuck in %{state} state: %{state_reason}: %{state_message}"
+      bad_image: "Pod `%{pod_name}` bad image: %{reason}: %{message}"
+      container_crash: "Pod's `%{pod_name}` container crashed: %{reason}: %{message}"
     secret:
       bad_data: "Data `%{data}` can't be decrypted: check encryption key and data!"
       key_length_too_short: "Encryption key isn't valid (required size %{required_size} bytes)!"

data/lib/dapp.rb

@@ -232,6 +232,7 @@ require 'dapp/dimg/dapp/command/build_context/export'
 require 'dapp/dimg/dapp/command/build_context/import'
 require 'dapp/dimg/dapp/command/build_context/common'
 require 'dapp/dimg/dapp/dappfile'
+require 'dapp/dimg/dapp/dimg'
 require 'dapp/dimg/dapp/dapp'
 require 'dapp/dimg/docker_registry'
 require 'dapp/dimg/docker_registry/base/request'
@@ -254,6 +255,7 @@ require 'dapp/dimg/lock/base'
 require 'dapp/dimg/lock/file'
 require 'dapp/dimg/filelock'
 require 'dapp/dimg/git_repo/base'
+require 'dapp/dimg/git_repo/local'
 require 'dapp/dimg/git_repo/own'
 require 'dapp/dimg/git_repo/remote'
 require 'dapp/dimg/git_artifact'

data/lib/dapp/dapp.rb

@@ -71,11 +71,14 @@ module Dapp
     end
 
     def git_own_repo_exist?
-      git_own_repo.exist?
+      !git_own_repo.nil?
     end
 
     def git_own_repo
       @git_own_repo ||= Dimg::GitRepo::Own.new(self)
+    rescue Dimg::Error::Rugged => e
+      raise unless e.net_status[:code] == :local_git_repository_does_not_exist
+      nil
     end
 
     def path(*path)

data/lib/dapp/dimg/build/stage/artifact_base.rb

@@ -22,9 +22,8 @@ module Dapp
           def artifacts
             @artifacts ||= begin
               dimg.config.public_send("_#{name}").map do |artifact|
-                artifact_dimg = ::Dapp::Dimg::Artifact.new(config: artifact._config,
-                                                           dapp: dimg.dapp,
-                                                           ignore_git_fetch: dimg.ignore_git_fetch)
+                artifact_dimg = dimg.dapp.artifact_dimg(config: artifact._config,
+                                                        ignore_git_fetch: dimg.ignore_git_fetch)
                 { name: artifact._config._name, options: artifact._artifact_options, dimg: artifact_dimg }
               end
             end

data/lib/dapp/dimg/config/directive/artifact_dimg.rb

@@ -5,13 +5,6 @@ module Dapp
         class ArtifactDimg < Dimg
           def validate_scratch!
           end
-
-          def validate_artifacts_artifacts!
-          end
-
-          def validated_artifacts
-            _git_artifact._local + _git_artifact._remote
-          end
         end
       end
     end

data/lib/dapp/dimg/config/directive/dimg/instance_methods.rb

@@ -136,6 +136,7 @@ module Dapp
 
             def artifacts_after_parsing!
               _artifacts_auto_excluding!
+              _artifact.map(&:_config).each(&:artifacts_after_parsing!)
             end
 
             protected

data/lib/dapp/dimg/config/directive/dimg/validation.rb

@@ -71,12 +71,39 @@ module Dapp
                 verifiable_artifact = artifacts.shift
                 artifacts.select { |a| a[:to] == verifiable_artifact[:to] }.each do |artifact|
                   next if verifiable_artifact[:index] == artifact[:index]
-                  validate_artifact!(verifiable_artifact, artifact)
-                  validate_artifact!(artifact, verifiable_artifact)
+                  begin
+                    validate_artifact!(verifiable_artifact, artifact)
+                    validate_artifact!(artifact, verifiable_artifact)
+                  rescue ::Dapp::Error::Config => e
+                    conflict_between_artifacts!(artifact, verifiable_artifact) if e.net_status[:code] == :artifact_conflict
+                    raise
+                  end
                 end
               end
             end
 
+            def conflict_between_artifacts!(*formatted_artifacts)
+              artifacts = formatted_artifacts.flatten.map { |formatted_artifact| formatted_artifact[:related_artifact] }
+              dappfile_context = artifacts.map do |artifact|
+                artifact_directive = []
+                artifact_directive << begin
+                  if artifact.is_a? Artifact::Export
+                    "artifact.export('#{artifact._cwd}') do"
+                  else
+                    "git#{"('#{artifact._url}')" if artifact.respond_to?(:_url)}.add('#{artifact._cwd}') do"
+                  end
+                end
+                [:include_paths, :exclude_paths].each do |directive|
+                  next if (paths = artifact.send("_#{directive}")).empty?
+                  artifact_directive << "  #{directive} '#{paths.join("', '")}'"
+                end
+                artifact_directive << "  to '#{artifact._to}'"
+                artifact_directive << 'end'
+                artifact_directive.join("\n")
+              end.join("\n\n")
+              raise ::Dapp::Error::Config, code: :artifact_conflict, data: { dappfile_context: dappfile_context }
+            end
+
             def validate_artifact_format(artifacts)
               artifacts.map do |a|
                 path_format = proc { |path| File.expand_path(File.join('/', path, '/'))[1..-1] }
@@ -104,7 +131,8 @@ module Dapp
                   index: artifacts.index(a),
                   to: to,
                   include_paths: include_paths,
-                  exclude_paths: exclude_paths
+                  exclude_paths: exclude_paths,
+                  related_artifact: a
                 }
               end
             end
@@ -113,17 +141,26 @@ module Dapp
               verifiable_artifact[:include_paths].each do |verifiable_path|
                 potential_conflicts = artifact[:include_paths].select { |path| path.start_with?(verifiable_path) }
                 validate_artifact_path!(verifiable_artifact, potential_conflicts)
-              end.empty? && verifiable_artifact[:exclude_paths].empty? && raise(::Dapp::Error::Config, code: :artifact_conflict)
-              validate_artifact_path!(verifiable_artifact, artifact[:include_paths]) if verifiable_artifact[:include_paths].empty?
+              end
+
+              if verifiable_artifact[:include_paths].empty?
+                if artifact[:include_paths].empty? || verifiable_artifact[:exclude_paths].empty?
+                  raise ::Dapp::Error::Config, code: :artifact_conflict
+                else
+                  validate_artifact_path!(verifiable_artifact, artifact[:include_paths])
+                end
+              end
             end
 
             def validate_artifact_path!(verifiable_artifact, potential_conflicts)
-              potential_conflicts.all? do |path|
-                loop do
-                  break if verifiable_artifact[:exclude_paths].include?(path) || ((path = File.dirname(path)) == '.')
+              raise ::Dapp::Error::Config, code: :artifact_conflict unless begin
+                potential_conflicts.all? do |path|
+                  loop do
+                    break if verifiable_artifact[:exclude_paths].include?(path) || ((path = File.dirname(path)) == '.')
+                  end
+                  verifiable_artifact[:exclude_paths].include?(path)
                 end
-                verifiable_artifact[:exclude_paths].include?(path)
-              end.tap { |res| res || raise(::Dapp::Error::Config, code: :artifact_conflict) }
+              end
             end
 
             def _associated_artifacts

data/lib/dapp/dimg/dapp/command/build.rb

@@ -8,7 +8,7 @@ module Dapp
 
             build_configs.each do |config|
               log_dimg_name_with_indent(config) do
-                Dimg.new(config: config, dapp: self).build!
+                dimg(config: config).build!
               end
             end
           rescue ::Dapp::Error::Shellout, Error::Default

data/lib/dapp/dimg/dapp/command/build_context/export.rb

@@ -14,7 +14,7 @@ module Dapp
             def export_build_context_image_tar
               lock("#{name}.images", readonly: true) do
                 context_images_names = build_configs.map do |config|
-                  Dimg.new(config: config, dapp: self, ignore_git_fetch: true).tagged_images.map(&:name)
+                  dimg(config: config, ignore_git_fetch: true).tagged_images.map(&:name)
                 end.flatten
 
                 log_secondary_process(:images, short: true) do

data/lib/dapp/dimg/dapp/command/common.rb

@@ -123,9 +123,7 @@ module Dapp
             validate_repo_name!(repo)
             build_configs.each do |config|
               log_dimg_name_with_indent(config) do
-                Dimg.new(config: config, dapp: self, ignore_git_fetch: true, should_be_built: should_be_built).tap do |dimg|
-                  yield dimg
-                end
+                yield dimg(config: config, ignore_git_fetch: true, should_be_built: should_be_built)
               end
             end
           end

data/lib/dapp/dimg/dapp/command/run.rb

@@ -6,7 +6,7 @@ module Dapp
           def run(docker_options, command)
             one_dimg!
             setup_ssh_agent
-            Dimg.new(config: build_configs.first, dapp: self, ignore_git_fetch: true, should_be_built: true).run(docker_options, command)
+            dimg(config: build_configs.first, ignore_git_fetch: true, should_be_built: true).run(docker_options, command)
           end
         end
       end

data/lib/dapp/dimg/dapp/command/stage_image.rb

@@ -5,7 +5,7 @@ module Dapp
         module StageImage
           def stage_image
             one_dimg!
-            puts Dimg.new(config: build_configs.first, dapp: self, ignore_git_fetch: true).stage_image_name(options[:stage])
+            puts dimg(config: build_configs.first, ignore_git_fetch: true).stage_image_name(options[:stage])
           end
         end
       end

data/lib/dapp/dimg/dapp/command/stages/common.rb

@@ -56,7 +56,7 @@ module Dapp
             def dapp_git_repositories
               @dapp_git_repositories ||= begin
                 {}.tap do |repositories|
-                  dimgs = build_configs.map { |config| Dimg.new(config: config, dapp: self, ignore_git_fetch: true) }
+                  dimgs = build_configs.map { |config| dimg(config: config, ignore_git_fetch: true) }
                   dimgs.each do |dimg|
                     [dimg, dimg.artifacts]
                       .flatten

data/lib/dapp/dimg/dapp/dapp.rb

@@ -3,6 +3,7 @@ module Dapp
     module Dapp
       module Dapp
         include Dappfile
+        include Dimg
 
         include Command::Common
         include Command::Run

data/lib/dapp/dimg/dapp/dimg.rb

@@ -0,0 +1,15 @@
+module Dapp
+  module Dimg
+    module Dapp
+      module Dimg
+        def dimg(config:, **kwargs)
+          (@dimgs ||= {})[config._name] ||= ::Dapp::Dimg::Dimg.new(config: config, dapp: self, **kwargs)
+        end
+
+        def artifact_dimg(config:, **kwargs)
+          (@artifacts_dimgs ||= {})[config._name] ||= ::Dapp::Dimg::Artifact.new(config: config, dapp: self, **kwargs)
+        end
+      end # Dimg
+    end # Dapp
+  end # Dimg
+end # Dapp

data/lib/dapp/dimg/dimg/git_artifact.rb

@@ -8,8 +8,9 @@ module Dapp
 
         def local_git_artifacts
           @local_git_artifact_list ||= [].tap do |artifacts|
+            break artifacts if (local_git_artifacts = Array(config._git_artifact._local)).empty?
             repo = GitRepo::Own.new(self)
-            Array(config._git_artifact._local).map do |ga_config|
+            local_git_artifacts.map do |ga_config|
               artifacts.concat(generate_git_artifacts(repo, **ga_config._artifact_options))
             end
           end
@@ -27,14 +28,14 @@ module Dapp
         def generate_git_artifacts(repo, **git_artifact_options)
           [].tap do |artifacts|
             artifacts << (artifact = ::Dapp::Dimg::GitArtifact.new(repo, **git_artifact_options))
-            artifacts.concat(generate_git_submodules_artifacts(artifact))
+            artifacts.concat(generate_git_embedded_artifacts(artifact))
           end
         end
 
-        def generate_git_submodules_artifacts(artifact)
+        def generate_git_embedded_artifacts(artifact)
           [].tap do |artifacts|
-            artifacts.concat(submodules_artifacts = artifact.submodules_artifacts)
-            artifacts.concat(submodules_artifacts.map(&method(:generate_git_submodules_artifacts)).flatten)
+            artifacts.concat(submodules_artifacts = artifact.embedded_artifacts)
+            artifacts.concat(submodules_artifacts.map(&method(:generate_git_embedded_artifacts)).flatten)
           end
         end
       end # GitArtifact

data/lib/dapp/dimg/git_artifact.rb

@@ -33,6 +33,10 @@ module Dapp
       end
       # rubocop:enable Metrics/ParameterLists
 
+      def embedded_artifacts
+        [submodules_artifacts, nested_git_directory_artifacts].flatten
+      end
+
       def submodules_artifacts
         commit = dev_mode? ? nil : latest_commit
         repo.submodules_params(commit,
@@ -41,65 +45,72 @@ module Dapp
       end
 
       def submodule_artifact(submodule_params)
-        submodule_rel_path = submodule_params[:path]
-        submodule_repo     = begin
-          GitRepo::Remote.new(repo.dimg, submodule_rel_path,
-                              url: submodule_url(submodule_params[:url])).tap { |r| r.fetch!(submodule_params[:branch]) }
-        rescue Rugged::InvalidError => e
-          raise Error::Rugged, code: :incorrect_gitmodules_file, data: { error: e.message }
-        end
+        embedded_artifact(submodule_params)
+      rescue Rugged::InvalidError => e
+        raise Error::Rugged, code: :incorrect_gitmodules_file, data: { error: e.message }
+      end
 
-        self.class.new(submodule_repo, submodule_artifact_options(submodule_params))
+      def nested_git_directory_artifacts
+        return [] unless dev_mode?
+        repo
+          .nested_git_directories_patches(paths: include_paths_or_cwd, exclude_paths: exclude_paths(true), **diff_patches_options)
+          .map(&method(:nested_git_directory_artifact))
       end
 
-      def submodule_url(url)
-        if url.start_with?('../')
-          case repo.remote_origin_url_protocol
-          when :http, :https, :git
-            uri = URI.parse(repo.remote_origin_url)
-            uri.path = File.expand_path(File.join(uri.path, url))
-            uri.to_s
-          when :ssh
-            host_with_user, group_and_project = repo.remote_origin_url.split(':', 2)
-            group_and_project = File.expand_path(File.join('/', group_and_project, url))[1..-1]
-            [host_with_user, group_and_project].join(':')
+      def nested_git_directory_artifact(patch)
+        params = {}.tap do |p|
+          p[:path] = patch.delta.new_file[:path]
+          p[:type] = :local
+        end
+        embedded_artifact(params)
+      end
+
+      def embedded_artifact(embedded_params)
+        embedded_rel_path = embedded_params[:path]
+        embedded_repo     = begin
+          if embedded_params[:type] == :remote
+            GitRepo::Remote.new(repo.dimg, embedded_rel_path,
+                                url: embedded_params[:url]).tap { |r| r.fetch!(embedded_params[:branch]) }
+          elsif embedded_params[:type] == :local
+            embedded_path = File.join(repo.workdir_path, embedded_params[:path])
+            GitRepo::Local.new(repo.dimg, embedded_rel_path, embedded_path)
           else
             raise
           end
-        else
-          url
         end
+
+        self.class.new(embedded_repo, embedded_artifact_options(embedded_params))
       end
 
-      def submodule_artifact_options(submodule_params)
-        submodule_rel_path = submodule_params[:path]
+      def embedded_artifact_options(embedded_params)
+        embedded_rel_path = embedded_params[:path]
 
         {}.tap do |options|
-          options[:name]                = repo.dapp.consistent_uniq_slugify("submodule-#{submodule_rel_path}")
-          options[:cwd]                 = submodule_inherit_path(cwd, submodule_rel_path).last
-          options[:to]                  = File.join(to, submodule_rel_path)
-          options[:include_paths]       = submodule_inherit_paths(include_paths, submodule_rel_path)
-          options[:exclude_paths]       = submodule_inherit_paths(exclude_paths, submodule_rel_path)
+          options[:name]                = repo.dapp.consistent_uniq_slugify("embedded-#{embedded_rel_path}")
+          options[:cwd]                 = embedded_inherit_path(cwd, embedded_rel_path).last
+          options[:to]                  = File.join(to, embedded_rel_path)
+          options[:include_paths]       = embedded_inherit_paths(include_paths, embedded_rel_path)
+          options[:exclude_paths]       = embedded_inherit_paths(exclude_paths, embedded_rel_path)
           options[:stages_dependencies] = begin
             stages_dependencies
-              .map { |stage, paths| [stage, submodule_inherit_paths(paths, submodule_rel_path)] }
+              .map { |stage, paths| [stage, embedded_inherit_paths(paths, embedded_rel_path)] }
               .to_h
           end
-          options[:branch]              = submodule_params[:branch]
+          options[:branch]              = embedded_params[:branch]
           options[:owner]               = owner
           options[:group]               = group
         end
       end
 
-      def submodule_inherit_paths(paths, submodule_rel_path)
+      def embedded_inherit_paths(paths, embedded_rel_path)
         paths
-          .select { |path| check_path?(submodule_rel_path, path) || check_subpath?(submodule_rel_path, path) }
-          .map { |path| submodule_inherit_path(path, submodule_rel_path) }
+          .select { |path| check_path?(embedded_rel_path, path) || check_subpath?(embedded_rel_path, path) }
+          .map { |path| embedded_inherit_path(path, embedded_rel_path) }
           .flatten
           .compact
       end
 
-      def submodule_inherit_path(path, submodule_rel_path)
+      def embedded_inherit_path(path, embedded_rel_path)
         path_parts      = path.split('/')
         test_path       = nil
         inherited_paths = []
@@ -107,7 +118,7 @@ module Dapp
           last_part_path = path_parts.shift
           test_path      = [test_path, last_part_path].compact.join('/')
 
-          non_match    = !File.fnmatch(test_path, submodule_rel_path, File::FNM_PATHNAME)
+          non_match    = !File.fnmatch(test_path, embedded_rel_path, File::FNM_PATHNAME)
           part_for_all = (last_part_path == '**')
 
           if non_match || part_for_all
@@ -462,16 +473,23 @@ module Dapp
 
       def diff_patches(from_commit, to_commit, paths: include_paths_or_cwd)
         (@diff_patches ||= {})[[from_commit, to_commit, paths]] ||= begin
-          options = {}.tap do |opts|
-            opts[:force_text] = true
-            if dev_mode?
-              opts[:include_untracked] = true
-              opts[:recurse_untracked_dirs] = true
+          repo
+            .patches(from_commit, to_commit, paths: paths, exclude_paths: exclude_paths(true), **diff_patches_options)
+            .select do |patch|
+              file_mode = patch.delta.new_file[:mode]
+              !(submodule_mode?(file_mode) || # FIXME: https://github.com/libgit2/rugged/issues/727
+                nested_git_directory_mode?(file_mode))
             end
+        end
+      end
+
+      def diff_patches_options
+        {}.tap do |opts|
+          opts[:force_text] = true
+          if dev_mode?
+            opts[:include_untracked] = true
+            opts[:recurse_untracked_dirs] = true
           end
-          repo
-            .patches(from_commit, to_commit, paths: paths, exclude_paths: exclude_paths(true), **options)
-            .select { |patch| !submodule_mode?(patch.delta.new_file[:mode]) } # FIXME: https://github.com/libgit2/rugged/issues/727
         end
       end
 
@@ -479,6 +497,10 @@ module Dapp
         mode == 0o160000
       end
 
+      def nested_git_directory_mode?(mode)
+        mode == 0o040000
+      end
+
       def include_paths_or_cwd
         case
         when !include_paths(true).empty? then include_paths(true)
@@ -530,7 +552,7 @@ module Dapp
       end
 
       def local?
-        repo.is_a? GitRepo::Own
+        repo.is_a? GitRepo::Local
       end
     end
   end

data/lib/dapp/dimg/git_repo/base.rb

@@ -63,6 +63,10 @@ module Dapp
           url_protocol(remote_origin_url)
         end
 
+        def nested_git_directories_patches(*_args)
+          raise
+        end
+
         def submodules_params(commit, paths: [], exclude_paths: [])
           raise "Workdir not supported for #{self.class}" if commit.nil?
 
@@ -82,10 +86,31 @@ module Dapp
             .map do |_, params|
               params = params.symbolize_keys
               params[:branch] = params[:branch].to_s if params.key?(:branch)
+              params[:url] = submodule_url(params[:url])
+              params[:type] = url_protocol(params[:url]) == :noname ? :local : :remote
               params
             end
         end
 
+        def submodule_url(gitsubmodule_url)
+          if gitsubmodule_url.start_with?('../')
+            case remote_origin_url_protocol
+            when :http, :https, :git
+              uri = URI.parse(remote_origin_url)
+              uri.path = File.expand_path(File.join(uri.path, gitsubmodule_url))
+              uri.to_s
+            when :ssh
+              host_with_user, group_and_project = remote_origin_url.split(':', 2)
+              group_and_project = File.expand_path(File.join('/', group_and_project, gitsubmodule_url))[1..-1]
+              [host_with_user, group_and_project].join(':')
+            else
+              raise
+            end
+          else
+            gitsubmodule_url
+          end
+        end
+
         # FIXME: Убрать логику исключения путей exclude_paths из данного класса,
         # FIXME: т.к. большинство методов не поддерживают инвариант
         # FIXME "всегда выдавать данные с исключенными путями".
@@ -98,16 +123,14 @@ module Dapp
 
         def patches(from, to, paths: [], exclude_paths: [], **kwargs)
           diff(from, to, **kwargs).patches.select do |patch|
-            delta_new_file = patch.delta.new_file
-            args = [delta_new_file[:path], paths: paths, exclude_paths: exclude_paths]
-            if delta_new_file[:mode] == 0o040000 # nested git repository in dev mode
-              !ignore_directory?(*args)
-            else
-              !ignore_path?(*args)
-            end
+            ignore_patch?(patch, paths: paths, exclude_paths: exclude_paths)
           end
         end
 
+        def ignore_patch?(patch, paths: [], exclude_paths: [])
+          !ignore_path?(patch.delta.new_file[:path], paths: paths, exclude_paths: exclude_paths)
+        end
+
         def entries(commit, paths: [], exclude_paths: [])
           [].tap do |entries|
             lookup_commit(commit).tree.walk(:preorder) do |root, entry|
@@ -183,13 +206,6 @@ module Dapp
           git.lookup(commit)
         end
 
-        def exist?
-          git
-          true
-        rescue Rugged::OSError
-          false
-        end
-
         protected
 
         attr_reader :manager

data/lib/dapp/dimg/git_repo/local.rb

@@ -0,0 +1,95 @@
+module Dapp
+  module Dimg
+    module GitRepo
+      class Local < Base
+        attr_reader :path
+
+        def initialize(manager, name, path)
+          super(manager, name)
+          self.path = path
+        end
+
+        def path=(path)
+          @path ||= Pathname(Rugged::Repository.new(path).path)
+        rescue Rugged::RepositoryError, Rugged::OSError => _e
+          raise Error::Rugged, code: :local_git_repository_does_not_exist, data: { path: path }
+        end
+
+        def workdir_path
+          Pathname(git.workdir)
+        end
+
+        def nested_git_directories_patches(paths: [], exclude_paths: [], **kwargs)
+          patches(nil, nil, paths: paths, exclude_paths: exclude_paths, **kwargs).select do |patch|
+            delta_new_file = patch.delta.new_file
+            nested_git_repository_mode?(delta_new_file[:mode])
+          end
+        end
+
+        # NOTICE: Параметры {from: nil, to: nil} можно указать только для Own repo.
+        # NOTICE: Для Remote repo такой вызов не имеет смысла и это ошибка пользователя класса Remote.
+
+        def submodules_params(commit, paths: [], exclude_paths: [])
+          return super unless commit.nil?
+          return []    unless File.file?((gitmodules_file_path = File.join(workdir_path, '.gitmodules')))
+
+          submodules_params_base(File.read(gitmodules_file_path),
+                                 paths: paths,
+                                 exclude_paths: exclude_paths).each do |submodule_params|
+            submodule_path = File.join(workdir_path, submodule_params[:path])
+            if git_repo_exist?(submodule_path)
+              dapp.log_info("Using local submodule `#{submodule_path}`!")
+              submodule_params[:type] = :local
+            end
+          end
+        end
+
+        def ignore_patch?(patch, paths: [], exclude_paths: [])
+          delta_new_file = patch.delta.new_file
+          args = [delta_new_file[:path], paths: paths, exclude_paths: exclude_paths]
+          if nested_git_repository_mode?(delta_new_file[:mode])
+            !ignore_directory?(*args)
+          else
+            !ignore_path?(*args)
+          end
+        end
+
+        def nested_git_repository_mode?(mode)
+          mode == 0o040000
+        end
+
+        def diff(from, to, **kwargs)
+          if from.nil? and to.nil?
+            mid_commit = latest_commit
+            diff_obj = super(nil, mid_commit, **kwargs)
+            diff_obj.merge! git.lookup(mid_commit).diff_workdir(**kwargs)
+            diff_obj
+          elsif to.nil?
+            git.lookup(from).diff_workdir(**kwargs)
+          else
+            super
+          end
+        end
+
+        def latest_commit(_branch = nil)
+          git.head.target_id
+        end
+
+        def lookup_commit(commit)
+          super
+        rescue Rugged::OdbError, TypeError => _e
+          raise Error::Rugged, code: :commit_not_found_in_local_git_repository, data: { commit: commit }
+        end
+
+        protected
+
+        def git_repo_exist?(path)
+          Rugged::Repository.new(path)
+          true
+        rescue Rugged::RepositoryError, Rugged::OSError => _e
+          false
+        end
+      end
+    end
+  end
+end

data/lib/dapp/dimg/git_repo/own.rb

@@ -1,63 +1,17 @@
 module Dapp
   module Dimg
     module GitRepo
-      class Own < Base
+      class Own < Local
         def initialize(manager)
-          super(manager, 'own')
+          super(manager, 'own', nil)
         end
 
-        def exclude_paths
-          dapp.local_git_artifact_exclude_paths
-        end
-
-        def workdir_path
-          Pathname(git.workdir)
-        end
-
-        def path
-          @path ||= Pathname(Rugged::Repository.discover(dapp.path.to_s).path)
-        rescue Rugged::RepositoryError => _e
-          raise Error::Rugged, code: :local_git_repository_does_not_exist
-        end
-
-        # NOTICE: Параметры {from: nil, to: nil} можно указать только для Own repo.
-        # NOTICE: Для Remote repo такой вызов не имеет смысла и это ошибка пользователя класса Remote.
-
-        def submodules_params(commit, paths: [], exclude_paths: [])
-          return super unless commit.nil?
-          return []    unless File.file?((gitmodules_file_path = File.join(workdir_path, '.gitmodules')))
-
-          submodules_params_base(File.read(gitmodules_file_path), paths: paths, exclude_paths: exclude_paths)
-        end
-
-        def diff(from, to, **kwargs)
-          if from.nil? and to.nil?
-            mid_commit = latest_commit
-            diff_obj = super(nil, mid_commit, **kwargs)
-            diff_obj.merge! git.lookup(mid_commit).diff_workdir(**kwargs)
-            diff_obj
-          elsif to.nil?
-            git.lookup(from).diff_workdir(**kwargs)
-          else
-            super
-          end
-        end
-
-        def latest_commit(_branch = nil)
-          git.head.target_id
+        def path=(_)
+          super(dapp.path.to_s)
         end
 
-        def lookup_commit(commit)
-          super
-        rescue Rugged::OdbError, TypeError => _e
-          raise Error::Rugged, code: :commit_not_found_in_local_git_repository, data: { commit: commit }
-        end
-
-        def exist?
-          super
-        rescue Error::Rugged => e
-          return false if e.net_status[:code] == :local_git_repository_does_not_exist
-          raise
+        def exclude_paths
+          dapp.local_git_artifact_exclude_paths
         end
       end
     end

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

@@ -27,7 +27,7 @@ module Dapp
               .reject { |job| ['0', 'false'].include? job.annotations["dapp/recreate"].to_s }
               .select { |job| all_jobs_names.include? job.name }
               .each do |job|
-                log_process("Delete hooks job `#{job.name}`", short: true) do
+                log_process("Delete hook job `#{job.name}` (dapp/recreate)", short: true) do
                   kube_delete_job!(job.name, all_pods_specs) unless dry_run?
                 end
               end
@@ -133,13 +133,18 @@ module Dapp
                   watch_hooks_condition.signal
                 end
 
-                release.deploy!
+                cmd_res = release.helm_upgrade!
+
+                if cmd_res.error?
+                  raise ::Dapp::Error::Command, code: :kube_helm_failed, data: {output: (cmd_res.stdout + cmd_res.stderr).strip}
+                else
+                  watch_hooks_thr.join if !dry_run? && watch_hooks_thr && watch_hooks_thr.alive?
+                  log_info((cmd_res.stdout + cmd_res.stderr).strip)
+                end
               end
 
               deployment_managers.each(&:after_deploy)
 
-              watch_hooks_thr.kill if !dry_run? && watch_hooks_thr && watch_hooks_thr.alive?
-
               unless dry_run?
                 begin
                   ::Timeout::timeout(self.options[:timeout] || 300) do

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

@@ -49,7 +49,7 @@ module Dapp
         end.to_h
       end
 
-      def deploy!
+      def helm_upgrade!
         args = [
           name, chart_path, additional_values_options,
           set_options, upgrade_extra_options
@@ -57,7 +57,9 @@ module Dapp
 
         dapp.kubernetes.create_namespace!(namespace) unless dapp.kubernetes.namespace?(namespace)
 
-        dapp.shellout! "helm upgrade #{args.join(' ')}", verbose: true
+        cmd = dapp.shellout "helm upgrade #{args.join(' ')}"
+
+        return cmd
       end
 
       def templates

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

@@ -63,7 +63,7 @@ module Dapp
           end
 
           dimgs = dapp.build_configs.map do |config|
-            ::Dapp::Dimg::Dimg.new(config: config, dapp: dapp, ignore_git_fetch: true)
+            dapp.dimg(config: config, ignore_git_fetch: true)
           end.uniq do |dimg|
             dimg.config._name
           end

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

@@ -2,6 +2,20 @@ module Dapp
   module Kube
     module Kubernetes::Client::Resource
       class Pod < Base
+        # Returns:
+        #   nil: no such condition yet
+        #   "True" string: ready
+        #   "False" string: not ready
+        def ready_condition_status
+          rd = self.ready_condition
+          return nil unless rd
+          return rd['status']
+        end
+
+        def ready_condition
+          status.fetch('conditions', {}).find {|condition| condition['type'] == 'Ready'}
+        end
+
         def container_id(container_name)
           container_status = spec.fetch('status', {})
             .fetch('containerStatuses')

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

@@ -18,7 +18,7 @@ module Dapp
           _, container_state_data = pod.container_state(name)
           return if @processed_containers_ids.include? container_state_data['containerID']
 
-          pod_manager.wait_till_running!
+          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)

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

@@ -22,6 +22,8 @@ module Dapp
               @deployment_before_deploy = Kubernetes::Client::Resource::Deployment.new(dapp.kubernetes.replace_deployment!(name, new_spec))
             end
           end
+
+          @deploy_began_at = Time.now
         end
 
         def after_deploy
@@ -116,7 +118,11 @@ module Dapp
                           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
+                          # Если под еще не перешел в состоянии готовности, то можно вывести все логи которые имеются.
+                          # Иначе выводим только новые логи с момента начала текущей сессии деплоя.
+                          if [nil, "True"].include? pod.ready_condition_status
+                            since_time = @deploy_began_at.utc.iso8601(9) if @deploy_began_at
+                          end
 
                           log_lines_by_time = []
                           begin
@@ -147,34 +153,8 @@ module Dapp
                         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 Kubernetes::Error::Base,
-                              code: :image_not_found,
-                              data: {pod_name: pod.name,
-                                     reason: waiting_reason,
-                                     message: container_status['state']['waiting']['message']}
-                          when 'CrashLoopBackOff'
-                            raise Kubernetes::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("#{dapp.log_time}Unknown pod readiness condition reason '#{ready_condition['reason']}': #{ready_condition}", stream: dapp.service_stream)
-                        end
-                      end
+                      pod_manager = Kubernetes::Manager::Pod.new(dapp, pod.name)
+                      pod_manager.check_readiness_condition_if_available!(pod)
                     end # with_log_indent
                   end # rs_pods.each
                 end # with_log_indent

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

@@ -9,10 +9,44 @@ module Dapp
           end
         end
 
-        def wait_till_running!
+        def check_readiness_condition_if_available!(pod)
+          return if [nil, "True"].include? pod.ready_condition_status
+
+          if pod.ready_condition['reason'] == 'ContainersNotReady'
+            [*Array(pod.status["initContainerStatuses"]), *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 Kubernetes::Error::Default,
+                  code: :bad_image,
+                  data: {pod_name: pod.name,
+                         reason: waiting_reason,
+                         message: container_status['state']['waiting']['message']}
+              when 'CrashLoopBackOff'
+                raise Kubernetes::Error::Default,
+                  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("#{dapp.log_time}Unknown pod readiness condition reason '#{pod.ready_condition['reason']}': #{pod.ready_condition}", stream: dapp.service_stream)
+            end
+          end
+        end
+
+        def wait_till_launched!
           loop do
             pod = Kubernetes::Client::Resource::Pod.new(dapp.kubernetes.pod(name))
-            break if pod.phase == 'Running'
+
+            break if pod.phase != "Pending"
+
+            check_readiness_condition_if_available!(pod)
+
             sleep 0.1
           end
         end

data/lib/dapp/version.rb

@@ -1,4 +1,4 @@
 module Dapp
-  VERSION = "0.24.3"
+  VERSION = "0.24.4"
   BUILD_CACHE_VERSION = 26
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dapp
 version: !ruby/object:Gem::Version
-  version: 0.24.3
+  version: 0.24.4
 platform: ruby
 authors:
 - Dmitry Stolyarov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-18 00:00:00.000000000 Z
+date: 2018-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mixlib-shellout
@@ -600,6 +600,7 @@ files:
 - lib/dapp/dimg/dapp/command/tag.rb
 - lib/dapp/dimg/dapp/dapp.rb
 - lib/dapp/dimg/dapp/dappfile.rb
+- lib/dapp/dimg/dapp/dimg.rb
 - lib/dapp/dimg/dimg.rb
 - lib/dapp/dimg/dimg/git_artifact.rb
 - lib/dapp/dimg/dimg/path.rb
@@ -624,6 +625,7 @@ files:
 - lib/dapp/dimg/filelock.rb
 - lib/dapp/dimg/git_artifact.rb
 - lib/dapp/dimg/git_repo/base.rb
+- lib/dapp/dimg/git_repo/local.rb
 - lib/dapp/dimg/git_repo/own.rb
 - lib/dapp/dimg/git_repo/remote.rb
 - lib/dapp/dimg/image/argument.rb