dapp 0.10.2 → 0.36.24

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

@@ -2,30 +2,11 @@ module Dapp
   module Dimg
     module Build
       module Stage
-        class BuildArtifact < Base
-          include Mod::GitArtifactsDependencies
-
+        class BuildArtifact < Instructions
           def initialize(dimg)
             @prev_stage = GAArtifactPatch.new(dimg, self)
             @dimg = dimg
           end
-
-          def empty?
-            !dimg.builder.build_artifact?
-          end
-
-          def context
-            [git_artifacts_dependencies, builder_checksum]
-          end
-
-          def builder_checksum
-            dimg.builder.build_artifact_checksum
-          end
-
-          def prepare_image
-            super
-            dimg.builder.build_artifact(image)
-          end
         end # BuildArtifact
       end # Stage
     end # Build

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

@@ -9,13 +9,14 @@ module Dapp
           end
 
           def dependencies
-            [change_options]
+            @dependencies ||= [change_options]
           end
 
           def prepare_image
-            super
-            change_options.each do |k, v|
-              image.public_send("add_change_#{k}", v)
+            super do
+              change_options.each do |k, v|
+                image.public_send("add_change_#{k}", v)
+              end
             end
           end
         end # DockerInstructions

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

@@ -4,30 +4,73 @@ module Dapp
       module Stage
         class From < Base
           def dependencies
-            [from_image_name, dimg.config._docker._from_cache_version, config_mounts_dirs]
+            @dependencies ||= [from_image_name, dimg.config._docker._from_cache_version, config_mounts]
+          end
+
+          def save_in_cache!
+            super
+            from_dimg.last_stage.save_in_cache! unless from_dimg.nil?
           end
 
           protected
 
           def prepare_image
-            from_image.pull!
-            raise Error::Build, code: :from_image_not_found, data: { name: from_image_name } unless from_image.tagged?
+            if !from_dimg.nil?
+              process = dimg.dapp.t(code: 'process.from_dimg_building', data: { name: from_dimg.name })
+              dimg.dapp.log_secondary_process(process) { from_dimg.build! }
+            elsif !from_image.tagged?
+              try_host_docker_login
+              from_image.pull!
+              raise Error::Build, code: :from_image_not_found, data: { name: from_image_name } unless from_image.tagged?
+            end
+
             add_cleanup_mounts_dirs_command
             super
           end
 
+          def from_dimg
+            @from_dimg ||= begin
+              if !dimg.config._from_dimg.nil?
+                dimg.dapp.dimg_layer(config: dimg.config._from_dimg)
+              elsif !dimg.config._from_dimg_artifact.nil?
+                dimg.dapp.artifact_dimg_layer(config: dimg.config._from_dimg_artifact)
+              end
+            end
+          end
+
+          def try_host_docker_login
+            return unless registry_from_image_name?
+            dimg.dapp.host_docker_login(ENV['CI_REGISTRY'])
+          end
+
+          def registry_from_image_name?
+            ENV['CI_REGISTRY'] && from_image_name.start_with?(ENV['CI_REGISTRY'])
+          end
+
           def add_cleanup_mounts_dirs_command
             return if config_mounts_dirs.empty?
             image.add_service_command ["#{dimg.dapp.rm_bin} -rf %s",
-                                       "#{dimg.dapp.mkdir_bin} -p %s"].map { |c| format(c, config_mounts_dirs.join(' ')) }
+                                       "#{dimg.dapp.mkdir_bin} -p %s",
+                                       "#{dimg.dapp.rm_bin} -rf %s"].map { |c| format(c, config_mounts_dirs.join(' ')) }
+          end
+
+          def config_mounts
+            {}.tap do |mounts|
+              [:tmp_dir, :build_dir].map { |type| mounts[type] = config_mounts_by_type(type) }
+              config_custom_dir_mounts.each { |from, to| mounts[from] = to }
+            end
           end
 
           def config_mounts_dirs
-            [:tmp_dir, :build_dir].map { |type| config_mounts_by_type(type) }.flatten.uniq
+            config_mounts.values.flatten.uniq
+          end
+
+          def image_add_mounts
+            image_add_mounts_labels
           end
 
-          def adding_mounts_by_type(_type)
-            []
+          def image_should_be_untagged_condition
+            false
           end
 
           def should_not_be_detailed?
@@ -37,11 +80,21 @@ module Dapp
           private
 
           def from_image_name
-            dimg.config._docker._from
+            if !from_dimg.nil?
+              from_dimg.signature
+            else
+              dimg.config._docker._from
+            end
           end
 
           def from_image
-            @from_image ||= Image::Stage.image_by_name(name: from_image_name, dapp: dimg.dapp)
+            @from_image ||= begin
+              if !from_dimg.nil?
+                from_dimg.last_stage.image
+              else
+                Image::Stage.image_by_name(name: from_image_name, dapp: dimg.dapp)
+              end
+            end
           end
         end # Prepare
       end # Stage

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

@@ -4,12 +4,25 @@ module Dapp
       module Stage
         class GAArchive < GABase
           def initialize(dimg, next_stage)
-            @prev_stage = GAArchiveDependencies.new(dimg, self)
+            @prev_stage = BeforeInstallArtifact.new(dimg, self)
             super
           end
 
+          def dependencies
+            @dependencies ||= [dimg.git_artifacts.map(&:paramshash).join, reset_commits, dev_mode_dependencies]
+          end
+
+          def dev_mode_dependencies
+            return unless dimg.dev_mode?
+            dimg.git_artifacts.map(&:latest_commit)
+          end
+
           protected
 
+          def reset_commits
+            dimg.git_artifacts.map { |git_artifact| git_artifact.repo.find_commit_id_by_message('(\[dapp reset\])|(\[reset dapp\])') }.compact.sort.uniq
+          end
+
           def apply_command_method
             :apply_archive_command
           end

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

@@ -8,12 +8,8 @@ module Dapp
             super
           end
 
-          def empty?
-            dimg.git_artifacts.empty? || dependencies_empty?
-          end
-
           def dependencies
-            dimg.stage_by_name(:build_artifact).context
+            @dependencies ||= dimg.stage_by_name(:build_artifact).context
           end
         end # GAArtifactPatch
       end # Stage

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

@@ -3,51 +3,27 @@ module Dapp
     module Build
       module Stage
         class GABase < Base
-          def dependencies_stage
-            prev_stage
-          end
-
           def prepare_image
             super do
               image.add_volumes_from dimg.dapp.gitartifact_container
               image.add_volume "#{dimg.tmp_path('archives')}:#{dimg.container_tmp_path('archives')}:ro"
               image.add_volume "#{dimg.tmp_path('patches')}:#{dimg.container_tmp_path('patches')}:ro"
 
-              prepare_local_git_artifacts_command
-              prepare_remote_git_artifacts_command
+              dimg.git_artifacts.each do |git_artifact|
+                image.add_service_change_label(dimg.dapp.dimgstage_g_a_commit_label(git_artifact.paramshash).to_sym => layer_commit(git_artifact))
+                image.add_command git_artifact.send(apply_command_method, self)
+              end
             end
           end
 
-          def prepare_local_git_artifacts_command
-            prepare_base_git_artifacts_command(dimg.local_git_artifacts)
-          end
-
-          def prepare_remote_git_artifacts_command
-            prepare_base_git_artifacts_command(dimg.remote_git_artifacts)
-          end
-
-          def prepare_base_git_artifacts_command(git_artifacts)
-            git_artifacts.each { |git_artifact| image.add_command git_artifact.send(apply_command_method, self) }
-          end
-
           def empty?
-            dependencies_stage.empty?
+            dimg.git_artifacts.empty? || super
           end
 
           def g_a_stage?
             true
           end
 
-          def layer_commit(git_artifact)
-            commits[git_artifact] ||= begin
-              if dependencies_stage && dependencies_stage.image.tagged?
-                dependencies_stage.image.labels[git_artifact.full_name]
-              else
-                git_artifact.latest_commit
-              end
-            end
-          end
-
           protected
 
           def should_not_be_detailed?
@@ -61,12 +37,6 @@ module Dapp
           def apply_command_method
             :apply_patch_command
           end
-
-          private
-
-          def commits
-            @commits ||= {}
-          end
         end # GABase
       end # Stage
     end # Build

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

@@ -8,54 +8,35 @@ module Dapp
             super
           end
 
-          def dependencies_stage
-            nil
+          def renew
+            dependencies_discard
+            super
           end
 
           def dependencies
-            [].tap do |dependencies|
-              dependencies << commit_list
-              dependencies << dimg.local_git_artifacts.map { |git_artifact| git_artifact.dev_patch_hash(self) } if dimg.dapp.dev_mode?
-            end
+            @dependencies ||= [commit_list, git_artifacts_dev_patch_hashes]
           end
 
-          def prepare_local_git_artifacts_command
-            return super unless dimg.dapp.dev_mode?
-            dimg.local_git_artifacts.each { |git_artifact| image.add_command git_artifact.apply_dev_patch_command(self) }
+          def empty?
+            dimg.git_artifacts.empty? || dependencies_empty?
           end
 
           def layer_commit(git_artifact)
-            commits[git_artifact] ||= begin
-              git_artifact.latest_commit
-            end
-          end
-
-          def empty?
-            dependencies_empty? || git_artifacts_without_changes?
+            commits[git_artifact] ||= git_artifact.latest_commit
           end
 
           private
 
-          def git_artifacts_without_changes?
-            local_git_artifacts_without_changes? && remote_git_artifacts_without_changes?
-          end
-
-          def local_git_artifacts_without_changes?
-            dimg.local_git_artifacts.all? do |git_artifact|
-              from_commit = prev_g_a_stage.layer_commit(git_artifact)
-              to_commit = dimg.dev_mode? ? nil : layer_commit(git_artifact)
-              !git_artifact.any_changes?(from_commit, to_commit)
-            end
-          end
-
-          def remote_git_artifacts_without_changes?
-            dimg.remote_git_artifacts.all? do |git_artifact|
-              !git_artifact.any_changes?(prev_g_a_stage.layer_commit(git_artifact), layer_commit(git_artifact))
-            end
+          def commit_list
+            dimg.git_artifacts
+              .select { |ga| ga.repo.commit_exists?(prev_stage.layer_commit(ga)) && !ga.is_patch_empty(self) }
+              .map(&method(:layer_commit))
           end
 
-          def commit_list
-            dimg.git_artifacts.map { |git_artifact| layer_commit(git_artifact) }
+          def git_artifacts_dev_patch_hashes
+            # FIXME: dev-mode support in GitArtifact
+            # dimg.git_artifacts.map(&:dev_patch_hash)
+            nil
           end
         end # GALatestPatch
       end # Stage

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

@@ -0,0 +1,21 @@
+module Dapp
+  module Dimg
+    module Build
+      module Stage
+        class GARelatedBase < GABase
+          def dependencies
+            @dependencies ||= dimg.stage_by_name(related_stage_name).context
+          end
+
+          def empty?
+            dimg.stage_by_name(related_stage_name).context.compact.empty? || super
+          end
+
+          def related_stage_name
+            raise
+          end
+        end # GARelatedBase
+      end # Stage
+    end # Build
+  end # Dimg
+end # Dapp

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

@@ -8,20 +8,21 @@ module Dapp
           end
 
           def signature
-            @signature ||= hashsum [*dependencies.flatten, change_options]
+            hashsum [*dependencies.flatten, change_options]
           end
 
           def image
             @image ||= Image::Scratch.new(name: image_name, dapp: dimg.dapp)
           end
 
-          def image_add_volumes
+          def image_add_mounts
           end
 
           def prepare_image
-            super
-            change_options.each do |k, v|
-              image.public_send("add_change_#{k}", v)
+            super do
+              change_options.each do |k, v|
+                image.public_send("add_change_#{k}", v)
+              end
             end
           end
 
@@ -30,9 +31,9 @@ module Dapp
           def apply_artifact(artifact, image)
             return if dimg.dapp.dry_run?
 
-            artifact_name = artifact[:name]
             artifact_dimg = artifact[:dimg]
             cwd = artifact[:options][:cwd]
+            to = artifact[:options][:to]
             include_paths = artifact[:options][:include_paths]
             owner = artifact[:options][:owner]
             group = artifact[:options][:group]
@@ -44,19 +45,29 @@ module Dapp
             credentials += "--group=#{group} " if group
             credentials += '--numeric-owner'
 
-            archive_path = dimg.tmp_path('artifact', artifact_name, 'archive.tar.gz')
-            container_archive_path = File.join(artifact_dimg.container_tmp_path(artifact_name), 'archive.tar.gz')
+            archive_path = dimg.tmp_path('artifact', artifact_dimg.name, 'archive.tar.gz')
+            container_archive_path = File.join(artifact_dimg.container_tmp_path(artifact_dimg.name), 'archive.tar.gz')
 
             exclude_paths = artifact[:options][:exclude_paths].map { |path| "--exclude=#{path}" }.join(' ')
             include_paths = include_paths.empty? ? [File.join(cwd, '*')] : include_paths.map { |path| File.join(cwd, path, '*') }
             include_paths.map! { |path| path[1..-1] } # relative path
 
-            command = "#{sudo} #{dimg.dapp.tar_bin} -czf #{container_archive_path} #{exclude_paths} #{include_paths.join(' ')} #{credentials}"
-            run_artifact_dimg(artifact_dimg, artifact_name, command)
+            command = "#{sudo} #{dimg.dapp.tar_bin} #{tar_option_transform(cwd, to)} -czf #{container_archive_path} #{exclude_paths} #{include_paths.join(' ')} #{credentials}"
+            run_artifact_dimg(artifact_dimg, command)
 
             image.add_archive archive_path
           end
-          # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+          private
+
+          def tar_option_transform(cwd, to)
+            format = proc do |path|
+              res = path.chomp('/').reverse.chomp('/').reverse
+              res = res.gsub('/', '\/')
+              res
+            end
+            "--transform \"s/^#{format.call(cwd)}/#{format.call(to)}/\""
+          end
         end # ImportArtifact
       end # Stage
     end # Build

data/lib/dapp/dimg/build/stage/install/ga_post_install_patch.rb

@@ -3,13 +3,17 @@ module Dapp
     module Build
       module Stage
         module Install
-          class GAPostInstallPatch < GABase
+          class GAPostInstallPatch < GARelatedBase
             include Mod::Group
 
             def initialize(dimg, next_stage)
-              @prev_stage = GAPostInstallPatchDependencies.new(dimg, self)
+              @prev_stage = Install.new(dimg, self)
               super
             end
+
+            def related_stage_name
+              :before_setup
+            end
           end # GAPostInstallPatch
         end
       end # Stage

data/lib/dapp/dimg/build/stage/install/ga_pre_install_patch.rb

@@ -3,13 +3,17 @@ module Dapp
     module Build
       module Stage
         module Install
-          class GAPreInstallPatch < GABase
+          class GAPreInstallPatch < GARelatedBase
             include Mod::Group
 
             def initialize(dimg, next_stage)
-              @prev_stage = GAPreInstallPatchDependencies.new(dimg, self)
+              @prev_stage = GAArchive.new(dimg, self)
               super
             end
+
+            def related_stage_name
+              :install
+            end
           end # GAPostInstallPatch
         end
       end # Stage

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

@@ -3,31 +3,13 @@ module Dapp
     module Build
       module Stage
         module Install
-          class Install < Base
+          class Install < Instructions
             include Mod::Group
-            include Mod::GitArtifactsDependencies
 
             def initialize(dimg, next_stage)
               @prev_stage = GAPreInstallPatch.new(dimg, self)
               super
             end
-
-            def empty?
-              !dimg.builder.install?
-            end
-
-            def context
-              [git_artifacts_dependencies, builder_checksum]
-            end
-
-            def builder_checksum
-              dimg.builder.install_checksum
-            end
-
-            def prepare_image
-              super
-              dimg.builder.install(image)
-            end
           end # Install
         end # Install
       end # Stage

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

@@ -0,0 +1,27 @@
+module Dapp
+  module Dimg
+    module Build
+      module Stage
+        class Instructions < Base
+          def empty?
+            !dimg.builder.public_send(:"#{name}?")
+          end
+
+          def context
+            [git_artifacts_dependencies, builder_checksum]
+          end
+
+          def builder_checksum
+            dimg.builder.public_send(:"#{name}_checksum")
+          end
+
+          def prepare_image
+            super do
+              dimg.builder.public_send(name, image)
+            end
+          end
+        end # Instructions
+      end # Stage
+    end # Build
+  end # Dimg
+end # Dapp

data/lib/dapp/dimg/build/stage/mod/group.rb

@@ -5,7 +5,6 @@ module Dapp
         module Mod
           module Group
             def log_image_build
-              return super if should_be_quiet?
               log_group_name if group_should_be_opened?
               dimg.dapp.with_log_indent { super }
             end
@@ -19,18 +18,31 @@ module Dapp
             end
 
             def group_should_be_opened?
-              !group_opened? && image_should_be_build?
-            end
-
-            def group_opened?
-              return false if prev_group_stage.nil?
-              prev_group_stage.group_opened? || prev_group_stage.image_should_be_build?
+              @group_should_be_opened ||= begin
+                if empty?
+                  false
+                elsif prev_group_stage.nil?
+                  true
+                else
+                  prev_group_stages.all? { |s| !s.group_should_be_opened? }
+                end
+              end
             end
 
             def prev_group_stage
               prev_stage if prev_stage.respond_to?(:group_name) && prev_stage.group_name == group_name
             end
 
+            def prev_group_stages
+              @prev_group_stages ||= begin
+                if prev_group_stage.nil?
+                  []
+                else
+                  prev_group_stage.prev_group_stages + [prev_group_stage]
+                end
+              end
+            end
+
             def log_name_context
               [super, group_name].join('.')
             end

data/lib/dapp/dimg/build/stage/mod/logging.rb

@@ -4,19 +4,19 @@ module Dapp
       module Stage
         module Mod
           module Logging
-            def log_image_build(&image_build)
-              if empty?                    then log_state(:empty)
-              elsif image.built?           then log_state(:using_cache)
-              elsif should_be_not_present? then log_state(:not_present)
-              elsif dimg.dapp.dry_run?     then log_state(:build, styles: { status: :success })
-              else log_image_build_process(&image_build)
+            def log_image_build
+              case
+              when dimg.dapp.dry_run? && image_should_be_untagged? then log_state(:rebuild, styles: { status: :success })
+              when image.built?                                    then log_state(:using_cache)
+              when should_be_not_present?                          then log_state(:not_present)
+              when dimg.dapp.dry_run?                              then log_state(:build, styles: { status: :success })
+              else yield
               end
             ensure
               log_build
             end
 
             def log_build
-              return unless dimg.dapp.log_verbose? && !should_be_quiet?
               dimg.dapp.with_log_indent do
                 dimg.dapp.log_info dimg.dapp.t(code: 'image.signature', data: { signature: image_name })
                 log_image_details unless empty?
@@ -69,17 +69,9 @@ module Dapp
             end
 
             def log_state(state_code, styles: {})
-              return if should_be_quiet?
               dimg.dapp.log_state(log_name, state: dimg.dapp.t(code: state_code, context: 'state'), styles: styles)
             end
 
-            def log_image_build_process
-              dimg.dapp.log_process(log_name,
-                                    process: dimg.dapp.t(code: 'status.process.building'),
-                                    short: should_not_be_detailed?,
-                                    quiet: should_be_quiet?) { yield }
-            end
-
             def ignore_log_commands?
               false
             end
@@ -88,12 +80,16 @@ module Dapp
               image.send(:bash_commands).empty?
             end
 
-            def should_be_introspected?
-              dimg.stage_should_be_introspected?(name) && !dimg.dapp.dry_run?
+            def image_should_be_introspected?
+              image_should_be_introspected_after_build? || image_should_be_introspected_before_build?
+            end
+
+            def image_should_be_introspected_before_build?
+              dimg.stage_should_be_introspected_before_build?(name) && !dimg.dapp.dry_run?
             end
 
-            def should_be_quiet?
-              dimg.artifact? && !dimg.dapp.log_verbose?
+            def image_should_be_introspected_after_build?
+              dimg.stage_should_be_introspected_after_build?(name) && !dimg.dapp.dry_run?
             end
           end
         end # Mod