dapp 0.5.13 → 0.6.0

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

@@ -0,0 +1,21 @@
+module Dapp
+  module Build
+    module Stage
+      module InstallGroup
+        # GAPostInstallPatch
+        class GAPostInstallPatch < GABase
+          include Mod::Group
+
+          def initialize(application, next_stage)
+            @prev_stage = GAPostInstallPatchDependencies.new(application, self)
+            super
+          end
+
+          def next_g_a_stage
+            super.next_stage # GAPreSetupPatch
+          end
+        end # GAPostInstallPatch
+      end
+    end # Stage
+  end # Build
+end # Dapp

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

@@ -0,0 +1,21 @@
+module Dapp
+  module Build
+    module Stage
+      module InstallGroup
+        # GAPostInstallPatchDependencies
+        class GAPostInstallPatchDependencies < GADependenciesBase
+          include Mod::Group
+
+          def initialize(application, next_stage)
+            @prev_stage = Install.new(application, self)
+            super
+          end
+
+          def dependencies
+            [application.builder.before_setup_checksum]
+          end
+        end # GAPostInstallPatchDependencies
+      end
+    end # Stage
+  end # Build
+end # Dapp

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

@@ -0,0 +1,21 @@
+module Dapp
+  module Build
+    module Stage
+      module InstallGroup
+        # GAPostInstallPatch
+        class GAPreInstallPatch < GABase
+          include Mod::Group
+
+          def initialize(application, next_stage)
+            @prev_stage = GAPreInstallPatchDependencies.new(application, self)
+            super
+          end
+
+          def prev_g_a_stage
+            dependencies_stage.prev_stage # GAArchive
+          end
+        end # GAPostInstallPatch
+      end
+    end # Stage
+  end # Build
+end # Dapp

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

@@ -0,0 +1,31 @@
+module Dapp
+  module Build
+    module Stage
+      module InstallGroup
+        # GAPreInstallPatchDependencies
+        class GAPreInstallPatchDependencies < GADependenciesBase
+          include Mod::Group
+
+          def initialize(application, next_stage)
+            @prev_stage = GAArchive.new(application, self)
+            super
+          end
+
+          def dependencies
+            [install_dependencies_files_checksum, application.builder.install_checksum]
+          end
+
+          def empty?
+            super || dependencies_empty?
+          end
+
+          private
+
+          def install_dependencies_files_checksum
+            @install_dependencies_files_checksum ||= dependencies_files_checksum(application.config._install_dependencies)
+          end
+        end # GAPreInstallPatchDependencies
+      end
+    end # Stage
+  end # Build
+end # Dapp

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

@@ -0,0 +1,31 @@
+module Dapp
+  module Build
+    module Stage
+      module InstallGroup
+        # Install
+        class Install < Base
+          include Mod::Group
+
+          def initialize(application, next_stage)
+            @prev_stage = GAPreInstallPatch.new(application, self)
+            super
+          end
+
+          def empty?
+            super && !application.builder.install?
+          end
+
+          def dependencies
+            prev_stage.prev_stage.dependencies # GAPreInstallPatchDependencies
+          end
+
+          def image
+            super do |image|
+              application.builder.install(image)
+            end
+          end
+        end # Install
+      end
+    end # Stage
+  end # Build
+end # Dapp

data/lib/dapp/build/stage/mod/artifact.rb

@@ -7,15 +7,14 @@ module Dapp
         module Artifact
           def artifacts
             @artifacts ||= begin
-              verbose = application.log_verbose?
               application.config._artifact.map do |artifact|
-                process = application.t(code: 'process.artifact_building', data: { name: artifact._config._name })
-                application.log_secondary_process(process, short: !verbose) do
-                  application.with_log_indent do
+                process = application.project.t(code: 'process.artifact_building', data: { name: artifact._config._name })
+                application.project.log_secondary_process(process, short: !application.project.log_verbose?) do
+                  application.project.with_log_indent do
                     {
                       name: artifact._config._name,
                       options: artifact._artifact_options,
-                      app: Application.new(artifact_app_options(artifact, verbose)).tap(&:build!)
+                      app: application.artifact(artifact._config).tap(&:build!)
                     }
                   end
                 end
@@ -23,22 +22,13 @@ module Dapp
             end
           end
 
-          def artifact_app_options(artifact, verbose)
-            {
-              config: artifact._config,
-              cli_options: application.cli_options.merge(log_quiet: !verbose),
-              ignore_git_fetch: application.ignore_git_fetch,
-              is_artifact: true
-            }
-          end
-
           def artifacts_signatures
             artifacts.map { |artifact| hashsum [artifact[:app].signature, artifact[:options]] }
           end
 
           # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
           def apply_artifact(artifact, image)
-            return if application.dry_run?
+            return if application.project.dry_run?
 
             artifact_name = artifact[:name]
             app = artifact[:app]
@@ -52,8 +42,9 @@ module Dapp
                               "--volume #{application.tmp_path('artifact', artifact_name)}:#{app.container_tmp_path(artifact_name)}",
                               '--entrypoint /bin/bash']
             commands = safe_cp(where_to_add, app.container_tmp_path(artifact_name), Process.uid, Process.gid)
-            application.log_secondary_process(application.t(code: 'process.artifact_copy', data: { name: artifact_name }), short: true) do
-              app.run(docker_options, [%(-ec '#{application.shellout_pack(commands)}')])
+            application.project.log_secondary_process(application.project.t(code: 'process.artifact_copy',
+                                                                            data: { name: artifact_name }), short: true) do
+              app.run(docker_options, [%(-ec '#{application.project.shellout_pack(commands)}')])
             end
 
             commands = safe_cp(application.container_tmp_path('artifact', artifact_name), where_to_add, owner, group, cwd, paths)
@@ -68,8 +59,7 @@ module Dapp
             credentials += "-o #{owner} " if owner
             credentials += "-g #{group} " if group
 
-            copy_files = proc do |from_, cwd_, path_ = ''|
-              cwd_ = File.expand_path(File.join('/', cwd_))
+            copy_files = lambda do |from_, cwd_, path_ = ''|
               "find #{File.join(from_, cwd_, path_)} -type f -exec bash -ec 'install -D #{credentials} {} " \
             "#{File.join(to, "$(echo {} | sed -e \"s/#{File.join(from_, cwd_).gsub('/', '\\/')}//g\")")}' \\;"
             end

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

@@ -0,0 +1,42 @@
+module Dapp
+  module Build
+    module Stage
+      # Mod
+      module Mod
+        # Group
+        module Group
+          def log_image_build
+            return super if should_be_quiet?
+            log_group_name if group_should_be_opened?
+            application.project.with_log_indent { super }
+          end
+
+          def log_group_name
+            application.project.log_step(application.project.t(code: group_name, context: :group))
+          end
+
+          def group_name
+            class_to_lowercase(self.class.name.split('::')[-2])
+          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?
+          end
+
+          def prev_group_stage
+            prev_stage if prev_stage.respond_to?(:group_name) && prev_stage.group_name == group_name
+          end
+
+          def log_name_context
+            [super, group_name].join('.')
+          end
+        end
+      end # Mod
+    end # Stage
+  end # Build
+end # Dapp

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

@@ -5,42 +5,74 @@ module Dapp
       module Mod
         # Logging
         module Logging
+          def log_image_build(&image_build)
+            if empty?                            then log_state(:empty)
+            elsif image.tagged?                  then log_state(:using_cache)
+            elsif should_be_not_present?         then log_state(:not_present)
+            elsif application.project.dry_run?   then log_state(:build, styles: { status: :success })
+            else log_image_build_process(&image_build)
+            end
+          ensure
+            log_build
+          end
+
           def log_build
-            application.with_log_indent do
-              application.log_info application.t(code: 'image.signature', data: { signature: image_name })
-              unless empty?
-                log_image_info
-                log_image_commands unless ignore_log_commands?
-              end
-            end if application.log? && application.log_verbose?
+            application.project.with_log_indent do
+              application.project.log_info application.project.t(code: 'image.signature', data: { signature: image_name })
+              log_image_details unless empty?
+            end if application.project.log_verbose? && !should_be_quiet?
+          end
+
+          def log_image_details
+            if image.tagged?
+              log_image_created_at
+              log_image_size
+            end
+            log_image_commands unless ignore_log_commands?
+          end
+
+          def log_image_created_at
+            application.project.log_info application.project.t(code: 'image.info.created_at',
+                                                               data: { value: Time.parse(image.created_at).localtime })
+          end
+
+          def log_image_size
+            if from_image.tagged? && !prev_stage.nil?
+              size = image.size.to_f - from_image.size.to_f
+              code = 'image.info.difference'
+            else
+              size = image.size
+              code = 'image.info.size'
+            end
+            application.project.log_info application.project.t(code: code, data: { value: size.to_f.round(2) })
           end
 
           def log_image_commands
             return if (bash_commands = image.send(:bash_commands)).empty?
-            application.log_info application.t(code: 'image.commands')
-            application.with_log_indent { application.log_info bash_commands.join("\n") }
+            application.project.log_info application.project.t(code: 'image.commands')
+            application.project.with_log_indent { application.project.log_info bash_commands.join("\n") }
           end
 
-          def log_image_info
-            return unless image.tagged?
-            date, size = image_info
-            application.log_info application.t(code: 'image.info.date', data: { value: date })
-            size_code = size_difference? ? 'image.info.difference' : 'image.info.size'
-            application.log_info application.t(code: size_code, data: { value: size })
+          def log_name
+            application.project.t(code: name, context: log_name_context)
           end
 
-          def image_info
-            date, size = image.info
-            if size_difference?
-              _date, from_size = from_image.info
-              size = size.to_f - from_size.to_f
-            end
+          def log_name_context
+            :stage
+          end
 
-            [Time.parse(date).localtime, size.to_f.round(2)]
+          def log_state(state_code, styles: {})
+            application.project.log_state(log_name,
+                                          state: application.project.t(code: state_code, context: 'state'),
+                                          styles: styles) unless should_be_quiet?
           end
 
-          def size_difference?
-            from_image.tagged? && !prev_stage.nil?
+          def log_image_build_process
+            return yield if should_be_quiet?
+            application.project.log_process(log_name, process: application.project.t(code: 'status.process.building'),
+                                                      short: should_not_be_detailed?) do
+              yield
+            end
           end
 
           def ignore_log_commands?
@@ -48,7 +80,7 @@ module Dapp
           end
 
           def should_be_skipped?
-            image.tagged? && !application.log_verbose? && application.cli_options[:introspect_stage].nil?
+            image.tagged? && !application.project.log_verbose? && application.project.cli_options[:introspect_stage].nil?
           end
 
           def should_not_be_detailed?
@@ -56,7 +88,11 @@ module Dapp
           end
 
           def should_be_introspected?
-            application.cli_options[:introspect_stage] == name && !application.dry_run? && !application.is_artifact
+            application.project.cli_options[:introspect_stage] == name && !application.project.dry_run? && !application.is_artifact
+          end
+
+          def should_be_quiet?
+            application.is_artifact && !application.project.log_verbose?
           end
         end
       end # Mod

data/lib/dapp/build/stage/setup/chef_cookbooks.rb

@@ -0,0 +1,37 @@
+module Dapp
+  module Build
+    module Stage
+      module SetupGroup
+        # ChefCookbooks
+        class ChefCookbooks < Base
+          include Mod::Group
+
+          def initialize(application, next_stage)
+            @prev_stage = Setup.new(application, self)
+            super
+          end
+
+          def dependencies
+            [application.builder.chef_cookbooks_checksum]
+          end
+
+          def image
+            super do |image|
+              application.builder.chef_cookbooks(image)
+            end
+          end
+
+          protected
+
+          def should_not_be_detailed?
+            true
+          end
+
+          def ignore_log_commands?
+            true
+          end
+        end # ChefCookbooks
+      end
+    end # Stage
+  end # Build
+end # Dapp

data/lib/dapp/build/stage/setup/ga_post_setup_patch.rb

@@ -0,0 +1,25 @@
+module Dapp
+  module Build
+    module Stage
+      module SetupGroup
+        # GAPostSetupPatch
+        class GAPostSetupPatch < GABase
+          include Mod::Group
+
+          def initialize(application, next_stage)
+            @prev_stage = GAPostSetupPatchDependencies.new(application, self)
+            super
+          end
+
+          def prev_g_a_stage
+            super.prev_stage # GAPreSetupPatch
+          end
+
+          def next_g_a_stage
+            next_stage # GALatestPatch
+          end
+        end # GAPostSetupPatch
+      end
+    end # Stage
+  end # Build
+end # Dapp

data/lib/dapp/build/stage/setup/ga_post_setup_patch_dependencies.rb

@@ -0,0 +1,31 @@
+module Dapp
+  module Build
+    module Stage
+      module SetupGroup
+        # GAPostSetupPatchDependencies
+        class GAPostSetupPatchDependencies < GADependenciesBase
+          include Mod::Group
+
+          MAX_PATCH_SIZE = 1024 * 1024
+
+          def initialize(application, next_stage)
+            @prev_stage = ChefCookbooks.new(application, self)
+            super
+          end
+
+          def dependencies
+            [(changes_size_since_g_a_pre_setup_patch / MAX_PATCH_SIZE).to_i]
+          end
+
+          private
+
+          def changes_size_since_g_a_pre_setup_patch
+            application.git_artifacts.map do |git_artifact|
+              git_artifact.patch_size(prev_stage.prev_stage.prev_stage.layer_commit(git_artifact), git_artifact.latest_commit)
+            end.reduce(0, :+)
+          end
+        end # GAPostSetupPatchDependencies
+      end
+    end # Stage
+  end # Build
+end # Dapp