dapp 0.6.1 → 0.6.2

data/lib/dapp/application/path.rb

@@ -8,11 +8,12 @@ module Dapp
       end
 
       def tmp_path(*path)
+        @tmp_path ||= Dir.mktmpdir(project.cli_options[:tmp_dir_prefix] || 'dapp-')
         make_path(@tmp_path, *path).expand_path.tap { |p| p.parent.mkpath }
       end
 
-      def build_path
-        project.build_path.join(config._basename)
+      def build_path(*path)
+        make_path(project.build_path.join(config._basename), *path).expand_path.tap { |p| p.parent.mkpath }
       end
 
       def container_dapp_path(*path)

data/lib/dapp/application/stages.rb

@@ -0,0 +1,59 @@
+module Dapp
+  # Application
+  class Application
+    # Stages
+    module Stages
+      def signature
+        last_stage.send(:signature)
+      end
+
+      def stage_cache_format
+        "#{project.cache_format % { application_name: config._basename }}:%{signature}"
+      end
+
+      def stage_dapp_label
+        project.stage_dapp_label_format % { application_name: config._basename }
+      end
+
+      def images
+        (@images ||= []).tap do |images|
+          stages.map do |stage|
+            if stage.respond_to?(:images)
+              images.concat(stage.images)
+            else
+              images << stage.image
+            end
+          end.uniq(&:name)
+        end
+      end
+
+      protected
+
+      def last_stage
+        @last_stage ||= if scratch?
+                          Build::Stage::ImportArtifact.new(self)
+                        else
+                          Build::Stage::DockerInstructions.new(self)
+                        end
+      end
+
+      def export_images
+        images.select(&:tagged?)
+      end
+
+      def import_images
+        images.select { |image| !image.tagged? }
+      end
+
+      def stages
+        (@stages ||= []).tap do |stages|
+          stage = last_stage
+          loop do
+            stages << stage
+            break if (stage = stage.prev_stage).nil?
+          end
+        end
+      end
+    end # Stages
+  end # Application
+end # Dapp

data/lib/dapp/artifact.rb

@@ -0,0 +1,22 @@
+module Dapp
+  # Artifact
+  class Artifact < Application
+    def artifact?
+      true
+    end
+
+    def should_be_built?
+      false
+    end
+
+    def with_introspection
+      yield
+    end
+
+    protected
+
+    def last_stage
+      @last_stage ||= Build::Stage::BuildArtifact.new(self)
+    end
+  end # Artifact
+end # Dapp

data/lib/dapp/build/stage/after_install_artifact.rb

@@ -0,0 +1,13 @@
+module Dapp
+  module Build
+    module Stage
+      # AfterInstallArtifact
+      class AfterInstallArtifact < ArtifactDefault
+        def initialize(application, next_stage)
+          @prev_stage = InstallGroup::GAPostInstallPatch.new(application, self)
+          super
+        end
+      end # AfterInstallArtifact
+    end # Stage
+  end # Build
+end # Dapp

data/lib/dapp/build/stage/after_setup_artifact.rb

@@ -0,0 +1,17 @@
+module Dapp
+  module Build
+    module Stage
+      # AfterSetupArtifact
+      class AfterSetupArtifact < ArtifactDefault
+        def initialize(application, next_stage)
+          @prev_stage = if application.artifact?
+                          SetupGroup::ChefCookbooks.new(application, self)
+                        else
+                          SetupGroup::GAPostSetupPatch.new(application, self)
+                        end
+          super
+        end
+      end # AfterSetupArtifact
+    end # Stage
+  end # Build
+end # Dapp

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

@@ -0,0 +1,80 @@
+module Dapp
+  module Build
+    module Stage
+      # ArtifactBase
+      class ArtifactBase < Base
+        def dependencies
+          artifacts_signatures
+        end
+
+        def prepare_image
+          super
+          artifacts_applications_build!
+          artifacts_labels = {}
+          artifacts.each do |artifact|
+            apply_artifact(artifact, image)
+            artifacts_labels["dapp-artifact-#{artifact[:name]}".to_sym] = artifact[:app].send(:last_stage).image.built_id
+          end
+          image.add_service_change_label artifacts_labels
+        end
+
+        def images
+          [image].concat(artifacts.map { |artifact| artifact[:app].images }.flatten)
+        end
+
+        protected
+
+        def should_not_be_detailed?
+          true
+        end
+
+        def ignore_log_commands?
+          true
+        end
+
+        def artifacts
+          @artifacts ||= begin
+            application.config.public_send("_#{name}").map do |artifact|
+              app = Dapp::Artifact.new(config: artifact._config,
+                                       project: application.project,
+                                       ignore_git_fetch: application.ignore_git_fetch)
+              { name: artifact._config._name, options: artifact._artifact_options, app: app }
+            end
+          end
+        end
+
+        def artifacts_signatures
+          artifacts.map { |artifact| hashsum [artifact[:app].signature, artifact[:options]] }
+        end
+
+        def artifacts_applications_build!
+          artifacts.each do |artifact|
+            process = application.project.t(code: 'process.artifact_building', data: { name: artifact[:name] })
+            application.project.log_secondary_process(process,
+                                                      short: !application.project.log_verbose?,
+                                                      quiet: application.artifact? && !application.project.log_verbose?) do
+              application.project.with_log_indent do
+                artifact[:app].build!
+              end
+            end
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def run_artifact_app(app, artifact_name, commands)
+          docker_options = ['--rm',
+                            "--volume #{application.tmp_path('artifact', artifact_name)}:#{app.container_tmp_path(artifact_name)}",
+                            "--volumes-from #{application.project.base_container}",
+                            "--entrypoint #{application.project.bash_path}"]
+          application.project.log_secondary_process(application.project.t(code: 'process.artifact_copy',
+                                                                          data: { name: artifact_name }),
+                                                    short: true,
+                                                    quiet: application.artifact? && !application.project.log_verbose?) do
+            app.run(docker_options, [%(-ec '#{application.project.shellout_pack(commands)}')])
+          end
+        end
+        # rubocop:enable Metrics/AbcSize
+      end # ArtifactBase
+    end # Stage
+  end # Build
+end # Dapp

data/lib/dapp/build/stage/artifact_default.rb

@@ -0,0 +1,62 @@
+module Dapp
+  module Build
+    module Stage
+      # ArtifactDefault
+      class ArtifactDefault < ArtifactBase
+        protected
+
+        # rubocop:disable Metrics/AbcSize
+        def apply_artifact(artifact, image)
+          return if application.project.dry_run?
+
+          artifact_name = artifact[:name]
+          app = artifact[:app]
+          cwd = artifact[:options][:cwd]
+          paths = artifact[:options][:paths]
+          exclude_paths = artifact[:options][:exclude_paths]
+          owner = artifact[:options][:owner]
+          group = artifact[:options][:group]
+          where_to_add = artifact[:options][:where_to_add]
+
+          command = safe_cp(where_to_add, app.container_tmp_path(artifact_name), Process.uid, Process.gid, cwd, paths, exclude_paths)
+          run_artifact_app(app, artifact_name, command)
+
+          command = safe_cp(application.container_tmp_path('artifact', artifact_name), where_to_add, owner, group, '', paths, exclude_paths)
+          image.add_command command
+          image.add_volume "#{application.tmp_path('artifact', artifact_name)}:#{application.container_tmp_path('artifact', artifact_name)}:ro"
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+        private
+
+        # rubocop:disable Metrics/ParameterLists, Metrics/AbcSize, Metrics/MethodLength
+        def safe_cp(from, to, owner, group, cwd = '', paths = [], exclude_paths = [])
+          credentials = ''
+          credentials += "-o #{owner} " if owner
+          credentials += "-g #{group} " if group
+          excludes = find_command_excludes(from, cwd, exclude_paths).join(' ')
+
+          copy_files = proc do |from_, cwd_, path_ = ''|
+            cwd_ = File.expand_path(File.join('/', cwd_))
+            "#{application.project.find_path} #{File.join(from_, cwd_, path_)} #{excludes} -type f -exec " \
+            "#{application.project.bash_path} -ec '#{application.project.install_path} -D #{credentials} {} " \
+            "#{File.join(to, "$(#{application.project.echo_path} {} | " \
+            "#{application.project.sed_path} -e \"s/#{File.join(from_, cwd_).gsub('/', '\\/')}//g\")")}' \\;"
+          end
+
+          commands = []
+          commands << [application.project.install_path, credentials, '-d', to].join(' ')
+          commands.concat(paths.empty? ? Array(copy_files.call(from, cwd)) : paths.map { |path| copy_files.call(from, cwd, path) })
+          commands << "#{application.project.find_path} #{to} -type d -exec " \
+                      "#{application.project.bash_path} -ec '#{application.project.install_path} -d #{credentials} {}' \\;"
+          commands.join(' && ')
+        end
+        # rubocop:enable Metrics/ParameterLists, Metrics/AbcSize, Metrics/MethodLength
+
+        def find_command_excludes(from, cwd, exclude_paths)
+          exclude_paths.map { |path| "-not \\( -path #{File.join(from, cwd, path)} -prune \\)" }
+        end
+      end # ArtifactDefault
+    end # Stage
+  end # Build
+end # Dapp

data/lib/dapp/build/stage/base.rb

@@ -17,10 +17,11 @@ module Dapp
           @next_stage.prev_stage = self
         end
 
+        # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity
         def build_lock!
           return yield if application.project.dry_run?
 
-          try_lock = lambda do
+          try_lock = proc do
             next yield unless should_be_tagged?
 
             no_lock = false
@@ -44,19 +45,22 @@ module Dapp
             try_lock.call
           end
         end
+        # rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity
 
         def build!
           return if should_be_skipped?
           prev_stage.build! if prev_stage
-          log_image_build(&method(:image_build)) if image_should_be_build?
+          if image_should_be_build?
+            prepare_image unless image.tagged?
+            log_image_build(&method(:image_build))
+          end
           raise Exception::IntrospectImage, data: { built_id: image.built_id, options: image.send(:prepared_options) } if should_be_introspected?
         end
 
         def save_in_cache!
           prev_stage.save_in_cache! if prev_stage
           return unless should_be_tagged?
-          image.tag!(log_verbose: application.project.log_verbose?,
-                     log_time: application.project.log_time?) unless application.project.dry_run?
+          image.tag! unless application.project.dry_run?
         end
 
         def image
@@ -64,14 +68,29 @@ module Dapp
             if empty?
               prev_stage.image
             else
-              Image::Stage.new(name: image_name, from: from_image, project: application.project).tap do |image|
-                image.add_service_change_label dapp: application.stage_dapp_label
-                yield image if block_given?
-              end
+              Image::Stage.new(name: image_name, from: from_image, project: application.project)
             end
           end
         end
 
+        def prepare_image
+          return if application.project.dry_run?
+          image.add_volumes_from application.project.base_container
+          image_add_tmp_volumes(:tmp)
+          image_add_tmp_volumes(:build)
+          image.add_service_change_label dapp: application.stage_dapp_label
+          image.add_service_change_label 'dapp-cache-version'.to_sym => Dapp::BUILD_CACHE_VERSION
+        end
+
+        def image_add_tmp_volumes(type)
+          (application.config.public_send("_#{type}_dir")._store +
+            from_image.labels.select { |l, _| l == "dapp-#{type}-dir" }.map { |_, value| value.split(';') }.flatten).each do |path|
+            absolute_path = File.expand_path(File.join('/', path))
+            tmp_path = application.send("#{type}_path", absolute_path[1..-1]).tap(&:mkpath)
+            image.add_volume "#{tmp_path}:#{absolute_path}"
+          end
+        end
+
         def image_should_be_build?
           !empty? || application.project.log_verbose?
         end
@@ -99,10 +118,11 @@ module Dapp
         protected
 
         def image_build
-          image.build!(log_verbose: application.project.log_verbose?,
-                       log_time: application.project.log_time?,
-                       introspect_error: application.project.cli_options[:introspect_error],
-                       introspect_before_error: application.project.cli_options[:introspect_before_error])
+          image.build!
+        end
+
+        def should_be_skipped?
+          image.tagged? && !application.project.log_verbose? && !should_be_introspected?
         end
 
         def should_be_tagged?
@@ -127,6 +147,21 @@ module Dapp
         def name
           class_to_lowercase.to_sym
         end
+
+        def dependencies_files_checksum(regs)
+          regs.map! { |reg| File.directory?(File.join(application.project.path, reg)) ? File.join(reg, '**', '*') : reg }
+          unless (files = regs.map { |reg| Dir[File.join(application.project.path, reg)].map { |f| File.read(f) if File.file?(f) } }).empty?
+            hashsum files
+          end
+        end
+
+        def change_options
+          @change_options ||= begin
+            application.config._docker._change_options.to_h.delete_if do |_, val|
+              val.nil? || (val.respond_to?(:empty?) && val.empty?)
+            end
+          end
+        end
       end # Base
     end # Stage
   end # Build

data/lib/dapp/build/stage/before_install.rb

@@ -12,15 +12,16 @@ module Dapp
           super && !application.builder.before_install?
         end
 
-        def dependencies
+        def context
           [application.builder.before_install_checksum]
         end
 
-        def image
-          super do |image|
-            application.builder.before_install(image)
-          end
+        def prepare_image
+          super
+          application.builder.before_install(image)
         end
+
+        alias dependencies context
       end # BeforeInstall
     end # Stage
   end # Build

data/lib/dapp/build/stage/before_install_artifact.rb

@@ -0,0 +1,13 @@
+module Dapp
+  module Build
+    module Stage
+      # BeforeInstallArtifact
+      class BeforeInstallArtifact < ArtifactDefault
+        def initialize(application, next_stage)
+          @prev_stage = BeforeInstall.new(application, self)
+          super
+        end
+      end # BeforeInstallArtifact
+    end # Stage
+  end # Build
+end # Dapp

data/lib/dapp/build/stage/before_setup.rb

@@ -4,22 +4,21 @@ module Dapp
       # BeforeSetup
       class BeforeSetup < Base
         def initialize(application, next_stage)
-          @prev_stage = Artifact.new(application, self)
+          @prev_stage = AfterInstallArtifact.new(application, self)
           super
         end
 
         def empty?
-          super && !application.builder.before_setup?
+          !application.builder.before_setup?
         end
 
-        def dependencies
-          prev_stage.prev_stage.prev_stage.dependencies # GAPostInstallPatchDependencies
+        def context
+          [application.builder.before_setup_checksum]
         end
 
-        def image
-          super do |image|
-            application.builder.before_setup(image)
-          end
+        def prepare_image
+          super
+          application.builder.before_setup(image)
         end
       end # BeforeSetup
     end # Stage