dapp 0.7.36 → 0.8.0

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

@@ -21,7 +21,15 @@ module Dapp
         end
 
         def dependencies
-          [commit_list]
+          [].tap do |dependencies|
+            dependencies << commit_list
+            dependencies << dimg.local_git_artifacts.map { |git_artifact| git_artifact.dev_patch_hash(self) } if dimg.project.dev_mode?
+          end
+        end
+
+        def prepare_local_git_artifacts_command
+          return super unless dimg.project.dev_mode?
+          dimg.local_git_artifacts.each { |git_artifact| image.add_command git_artifact.apply_dev_patch_command(self) }
         end
 
         def layer_commit(git_artifact)
@@ -31,7 +39,7 @@ module Dapp
         end
 
         def empty?
-          dependencies_empty?
+          dependencies_empty? || dimg.git_artifacts.all? { |git_artifact| !git_artifact.any_changes?(prev_g_a_stage.layer_commit(git_artifact)) }
         end
 
         private

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

@@ -8,7 +8,7 @@ module Dapp
         end
 
         def signature
-          hashsum [*dependencies.flatten, change_options]
+          @signature ||= hashsum [*dependencies.flatten, change_options]
         end
 
         def image

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

@@ -14,10 +14,6 @@ module Dapp
           def dependencies
             next_stage.next_stage.context # Install
           end
-
-          def empty?
-            super || dependencies_empty?
-          end
         end # GAPreInstallPatchDependencies
       end
     end # Stage

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

@@ -31,7 +31,7 @@ module Dapp
           private
 
           def install_dependencies_files_checksum
-            @install_dependencies_files_checksum ||= dependencies_files_checksum(dimg.config._install_dependencies)
+            dependencies_files_checksum(dimg.config._install_dependencies)
           end
         end # Install
       end

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

@@ -7,7 +7,7 @@ module Dapp
         module Logging
           def log_image_build(&image_build)
             if empty?                            then log_state(:empty)
-            elsif image.tagged?                  then log_state(:using_cache)
+            elsif image.built?                   then log_state(:using_cache)
             elsif should_be_not_present?         then log_state(:not_present)
             elsif dimg.project.dry_run?          then log_state(:build, styles: { status: :success })
             else log_image_build_process(&image_build)
@@ -91,7 +91,7 @@ module Dapp
           end
 
           def should_be_introspected?
-            dimg.project.cli_options[:introspect_stage] == name && !dimg.project.dry_run? && !dimg.artifact?
+            dimg.stage_should_be_introspected?(name) && !dimg.project.dry_run?
           end
 
           def should_be_quiet?

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

@@ -11,10 +11,6 @@ module Dapp
             super
           end
 
-          def prev_g_a_stage
-            super.prev_stage # GAPreSetupPatch
-          end
-
           def next_g_a_stage
             next_stage.next_stage
           end

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

@@ -9,7 +9,7 @@ module Dapp
           MAX_PATCH_SIZE = 1024 * 1024
 
           def initialize(dimg, next_stage)
-            @prev_stage = ChefCookbooks.new(dimg, self)
+            @prev_stage = Setup.new(dimg, self)
             super
           end
 
@@ -21,7 +21,7 @@ module Dapp
 
           def changes_size_since_g_a_pre_setup_patch
             dimg.git_artifacts.map do |git_artifact|
-              git_artifact.patch_size(prev_stage.prev_stage.prev_stage.layer_commit(git_artifact), git_artifact.latest_commit)
+              git_artifact.patch_size(prev_stage.prev_stage.layer_commit(git_artifact), git_artifact.latest_commit)
             end.reduce(0, :+)
           end
         end # GAPostSetupPatchDependencies

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

@@ -14,10 +14,6 @@ module Dapp
           def prev_g_a_stage
             super.prev_stage.prev_stage # GAPostInstallPatch
           end
-
-          def next_g_a_stage
-            super.next_stage # GAPostSetupPatch || GAArtifactPatch
-          end
         end # GAPrePatch
       end
     end # Stage

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

@@ -31,7 +31,7 @@ module Dapp
           private
 
           def setup_dependencies_files_checksum
-            @setup_files_checksum ||= dependencies_files_checksum(dimg.config._setup_dependencies)
+            dependencies_files_checksum(dimg.config._setup_dependencies)
           end
         end # Setup
       end

data/lib/dapp/builder/base.rb

@@ -73,13 +73,6 @@ module Dapp
       def build_artifact_checksum
         raise
       end
-
-      def chef_cookbooks(_image)
-      end
-
-      def chef_cookbooks_checksum
-        []
-      end
     end # Base
   end # Builder
 end # Dapp

data/lib/dapp/builder/chef.rb

@@ -1,25 +1,17 @@
 module Dapp
   module Builder
-    # Chef
     class Chef < Base
-      LOCAL_COOKBOOK_CHECKSUM_PATTERNS = %w(
-        attributes/**/*
-        recipes/**/*
-        files/**/*
-        templates/**/*
-      ).freeze
-
       DEFAULT_CHEFDK_IMAGE = 'dappdeps/chefdk:0.17.3-1'.freeze # TODO: config, DSL, DEFAULT_CHEFDK_IMAGE
 
       %i(before_install install before_setup setup build_artifact).each do |stage|
+        define_method("#{stage}?") {!stage_empty?(stage)}
+
         define_method("#{stage}_checksum") do
           dimg.hashsum [stage_cookbooks_checksum(stage),
                         stage_attributes_raw(stage),
                         *stage_cookbooks_runlist(stage)]
         end
 
-        define_method("#{stage}?") { !stage_empty?(stage) }
-
         define_method(stage.to_s) do |image|
           unless stage_empty?(stage)
             image.add_volumes_from(chefdk_container)
@@ -33,188 +25,25 @@ module Dapp
         end
       end
 
-      def chef_cookbooks_checksum
-        stage_cookbooks_checksum(:chef_cookbooks)
-      end
-
-      def chef_cookbooks(image)
-        image.add_volume "#{cookbooks_vendor_path(chef_cookbooks_stage: true)}:#{dimg.container_dapp_path('chef_cookbooks')}"
-        image.add_command(
-          "#{dimg.project.mkdir_bin} -p /usr/share/dapp/chef_repo",
-          ["#{dimg.project.cp_bin} -a #{dimg.container_dapp_path('chef_cookbooks')} ",
-           '/usr/share/dapp/chef_repo/cookbooks'].join
-        )
-      end
-
       def before_dimg_should_be_built_check
         super
 
-        %i(before_install install before_setup setup chef_cookbooks).each do |stage|
+        %i(before_install install before_setup setup).each do |stage|
           unless stage_empty?(stage) || stage_cookbooks_checksum_path(stage).exist?
             raise ::Dapp::Error::Dimg, code: :chef_stage_checksum_not_calculated,
-                                       data: { stage: stage }
+                                       data: {stage: stage}
           end
         end
       end
 
       def before_build_check
         %i(before_install install before_setup setup build_artifact).tap do |stages|
-          (enabled_recipes - stages.map { |stage| stage_enabled_recipes(stage) }.flatten.uniq).each do |recipe|
-            dimg.project.log_warning(desc: { code: :recipe_does_not_used, data: { recipe: recipe } })
+          (builder_cookbook.enabled_recipes - stages.map {|stage| builder_cookbook.stage_enabled_recipes(stage)}.flatten.uniq).each do |recipe|
+            dimg.project.log_warning(desc: {code: :recipe_does_not_used, data: {recipe: recipe}})
           end
         end
       end
 
-      private
-
-      def stage_enabled_modules(stage)
-        @stage_enabled_modules ||= {}
-        @stage_enabled_modules[stage] ||= enabled_modules.select { |cookbook| stage_entry_exist?(stage, cookbook, stage) }
-      end
-
-      def stage_enabled_recipes(stage)
-        @stage_enabled_recipes ||= {}
-        @stage_enabled_recipes[stage] ||= enabled_recipes.select { |recipe| stage_entry_exist?(stage, project_name, recipe) }
-      end
-
-      def enabled_modules
-        dimg.config._chef._dimod
-      end
-
-      def enabled_recipes
-        dimg.config._chef._recipe
-      end
-
-      def stage_attributes(stage)
-        dimg.config._chef.send("__#{stage}_attributes")
-      end
-
-      def stage_attributes_raw(stage)
-        JSON.dump stage_attributes(stage)
-      end
-
-      def project_name
-        cookbook_metadata.name
-      end
-
-      def local_cookbook_path(*path)
-        dimg.local_cookbook_path.tap do |local_cookbook_path|
-          unless local_cookbook_path.exist?
-            raise Error, code: :local_cookbook_path_not_found,
-                         data: { path: local_cookbook_path }
-          end
-        end.join(*path)
-      end
-
-      def berksfile_path
-        local_cookbook_path('Berksfile')
-      end
-
-      def berksfile_lock_path
-        local_cookbook_path('Berksfile.lock')
-      end
-
-      def berksfile
-        @berksfile ||= begin
-          unless berksfile_path.exist?
-            raise Error, code: :cookbook_berksfile_not_found,
-                         data: { path: berksfile_path.to_s }
-          end
-
-          Berksfile.new(local_cookbook_path, berksfile_path).tap do |berksfile|
-            unless berksfile.local_cookbook? project_name
-              raise Error, code: :cookbook_not_specified_in_berksfile,
-                           data: { name: project_name, path: berksfile_path.to_s }
-            end
-          end
-        end
-      end
-
-      def cookbook_metadata_path
-        local_cookbook_path('metadata.rb')
-      end
-
-      def check_cookbook_metadata_path_exist!
-        unless cookbook_metadata_path.exist?
-          raise Error, code: :cookbook_metadata_not_found,
-                       data: { path: cookbook_metadata_path }
-        end
-      end
-
-      def cookbook_metadata
-        @cookbook_metadata ||= begin
-          check_cookbook_metadata_path_exist!
-
-          CookbookMetadata.new(cookbook_metadata_path).tap do |metadata|
-            metadata.depends.each do |dependency|
-              if dependency.start_with? 'mdapp-'
-                raise Error, code: :mdapp_dependency_in_metadata_forbidden,
-                             data: { dependency: dependency }
-              end
-            end
-          end
-        end
-      end
-
-      def berksfile_lock_checksum
-        dimg.hashsum(berksfile_lock_path.read) if berksfile_lock_path.exist?
-      end
-
-      def stage_cookbooks_checksum_path(stage)
-        dimg.build_path.join("#{cookbooks_checksum}.#{stage}.checksum")
-      end
-
-      def stage_cookbooks_checksum(stage)
-        if stage_cookbooks_checksum_path(stage).exist?
-          stage_cookbooks_checksum_path(stage).read.strip
-        else
-          checksum = if stage == :chef_cookbooks
-                       paths = Dir[cookbooks_vendor_path('**/*', chef_cookbooks_stage: true)].map(&Pathname.method(:new))
-
-                       dimg.hashsum [
-                         dimg.paths_content_hashsum(paths),
-                         *paths.map { |p| p.relative_path_from(cookbooks_vendor_path(chef_cookbooks_stage: true)).to_s }.sort
-                       ]
-                     else
-                       paths = Dir[stage_cookbooks_path(stage, '**/*')].map(&Pathname.method(:new))
-
-                       dimg.hashsum [
-                         dimg.paths_content_hashsum(paths),
-                         *paths.map { |p| p.relative_path_from(stage_cookbooks_path(stage)).to_s }.sort,
-                         stage == :before_install ? chefdk_image : nil
-                       ].compact
-                     end
-
-          stage_cookbooks_checksum_path(stage).tap do |path|
-            path.parent.mkpath
-            path.write "#{checksum}\n"
-          end
-
-          checksum
-        end
-      end
-
-      def cookbooks_checksum
-        @cookbooks_checksum ||= begin
-          paths = berksfile
-                  .local_cookbooks
-                  .values
-                  .map { |cookbook| cookbook[:path] }
-                  .product(LOCAL_COOKBOOK_CHECKSUM_PATTERNS)
-                  .map { |cb, dir| Dir[cb.join(dir)] }
-                  .flatten
-                  .map(&Pathname.method(:new))
-
-          dimg.hashsum [
-            dimg.paths_content_hashsum(paths),
-            *paths.map { |p| p.relative_path_from(berksfile.home_path).to_s }.sort,
-            (berksfile_lock_checksum unless dimg.project.dev_mode?),
-            *enabled_recipes,
-            *enabled_modules
-          ].compact
-        end
-      end
-
       def chefdk_image
         DEFAULT_CHEFDK_IMAGE # TODO: config, DSL, DEFAULT_CHEFDK_IMAGE
       end
@@ -239,218 +68,62 @@ module Dapp
         end
       end
 
-      def _update_berksfile_lock_cmd
-        vendor_tmp = SecureRandom.uuid
-
-        ["berks vendor -b #{berksfile_path} /tmp/#{vendor_tmp}",
-         "rm -rf /tmp/#{vendor_tmp}"].join(' && ')
-      end
+      def builder_cookbook
+        @builder_cookbook ||= begin
+          unless dimg.project.builder_cookbook_path.exist?
+            raise Error, code: :builder_cookbook_not_found,
+                         data: {path: dimg.project.builder_cookbook_path.to_s}
+          end
 
-      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      def install_cookbooks(dest_path, chef_cookbooks_stage: false)
-        check_cookbook_metadata_path_exist!
-
-        volumes_from = [dimg.project.base_container, chefdk_container]
-        process_code = [
-          'process',
-          chef_cookbooks_stage ? 'chef_cookbooks_stage_berks_vendor' : 'berks_vendor'
-        ].compact.join('.')
-
-        dimg.project.log_secondary_process(dimg.project.t(code: process_code)) do
-          before_vendor_commands = [].tap do |commands|
-            unless dimg.project.dev_mode? || chef_cookbooks_stage
-              commands.push(
-                ['if [ ! -f Berksfile.lock ] ; then ',
-                 "echo \"Berksfile.lock not found, to create run '#{_update_berksfile_lock_cmd}'\" 1>&2 ; ",
-                 'exit 1 ; ',
-                 'fi'].join
-              )
-            end
+          unless dimg.project.builder_cookbook_path.join('Berksfile').exist?
+            raise Error, code: :builder_cookbook_berksfile_not_found,
+                         data: {path: dimg.project.builder_cookbook_path.join('Berksfile').to_s}
           end
 
-          after_vendor_commands = [].tap do |commands|
-            if dimg.project.dev_mode?
-              commands.push(
-                ["#{dimg.project.install_bin} -o #{Process.uid} -g #{Process.gid} ",
-                 "--mode $(#{dimg.project.stat_bin} -c %a Berksfile.lock) ",
-                 "Berksfile.lock #{berksfile_lock_path}"].join
-              )
-            elsif !chef_cookbooks_stage
-              commands.push(
-                "export LOCKDIFF=$(#{dimg.project.diff_bin} -u1 #{berksfile_lock_path} Berksfile.lock)",
-                ['if [ "$LOCKDIFF" != "" ] ; then ',
-                 "echo -e \"",
-                 "Bad Berksfile.lock, run '#{_update_berksfile_lock_cmd}' ",
-                 "or manually apply change:\\n$LOCKDIFF\" 1>&2 ; ",
-                 'exit 1 ; ',
-                 'fi'].join
-              )
-            end
+          unless dimg.project.builder_cookbook_path.join('metadata.rb').exist?
+            raise Error, code: :builder_cookbook_metadata_not_found,
+                         data: {path: dimg.project.builder_cookbook_path.join('metadata.rb').to_s}
           end
 
-          vendor_commands = [
-            "#{dimg.project.mkdir_bin} -p ~/.ssh",
-            "echo \"Host *\" >> ~/.ssh/config",
-            "echo \"    StrictHostKeyChecking no\" >> ~/.ssh/config",
-            *berksfile
-              .local_cookbooks
-              .values
-              .map {|cookbook|
-                ["#{dimg.project.rsync_bin} --archive",
-                 #*cookbook[:chefignore].map {|path| "--exclude #{path}"}, # FIXME
-                 "--relative #{cookbook[:path]} /tmp/local_cookbooks",
-                ].join(' ')
-              },
-            "cd /tmp/local_cookbooks/#{berksfile_path.parent}",
-            *before_vendor_commands,
-            '/.dapp/deps/chefdk/bin/berks vendor /tmp/cookbooks',
-            *after_vendor_commands,
-            ["#{dimg.project.find_bin} /tmp/cookbooks -type d -exec #{dimg.project.bash_bin} -ec '",
-             "#{dimg.project.install_bin} -o #{Process.uid} -g #{Process.gid} --mode $(#{dimg.project.stat_bin} -c %a {}) -d ",
-             "#{dest_path}/$(echo {} | #{dimg.project.sed_bin} -e \"s/^\\/tmp\\/cookbooks//\")' \\;"].join,
-            ["#{dimg.project.find_bin} /tmp/cookbooks -type f -exec #{dimg.project.bash_bin} -ec '",
-             "#{dimg.project.install_bin} -o #{Process.uid} -g #{Process.gid} --mode $(#{dimg.project.stat_bin} -c %a {}) {} ",
-             "#{dest_path}/$(echo {} | #{dimg.project.sed_bin} -e \"s/\\/tmp\\/cookbooks//\")' \\;"].join,
-            "#{dimg.project.install_bin} -o #{Process.uid} -g #{Process.gid} --mode 0644 <(#{dimg.project.date_bin} +%s.%N) #{dest_path.join('.created_at')}"
-          ]
-
-          dimg.project.shellout!(
-            ['docker run --rm',
-             volumes_from.map { |container| "--volumes-from #{container}" }.join(' '),
-             *berksfile
-              .local_cookbooks
-              .values
-              .map { |desc| "--volume #{desc[:path]}:#{desc[:path]}" },
-             ("--volume #{dimg.project.ssh_auth_sock}:/tmp/dapp-ssh-agent" if dimg.project.ssh_auth_sock),
-             "--volume #{dest_path.tap(&:mkpath)}:#{dest_path}",
-             ('--env SSH_AUTH_SOCK=/tmp/dapp-ssh-agent' if dimg.project.ssh_auth_sock),
-             ('--env DAPP_CHEF_COOKBOOKS_VENDORING=1' if chef_cookbooks_stage),
-             "dappdeps/berksdeps:0.1.0 #{dimg.project.bash_bin} -ec '#{dimg.project.shellout_pack(vendor_commands.join(' && '))}'"].compact.join(' '),
-            log_verbose: dimg.project.log_verbose?
+          berksfile = Berksfile.from_file(dimg.project.builder_cookbook_path, dimg.project.builder_cookbook_path.join('Berksfile'))
+          metadata = CookbookMetadata.from_file(dimg.project.builder_cookbook_path.join('metadata.rb'))
+
+          Cookbook.new(self,
+            path: dimg.project.builder_cookbook_path,
+            berksfile: berksfile,
+            metadata: metadata,
+            enabled_recipes: dimg.config._chef._recipe,
+            enabled_modules: dimg.config._chef._dimod,
           )
         end
       end
-      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
-      def _cookbooks_vendor_path(chef_cookbooks_stage: false)
-        dimg.build_path.join(
-          ['cookbooks', chef_cookbooks_stage ? 'chef_cookbooks_stage' : nil].compact.join('.'),
-          cookbooks_checksum
-        )
+      def stage_attributes(stage)
+        dimg.config._chef.send("__#{stage}_attributes")
       end
 
-      def cookbooks_vendor_path(*path, chef_cookbooks_stage: false)
-        _cookbooks_vendor_path(chef_cookbooks_stage: chef_cookbooks_stage).tap do |_cookbooks_path|
-          lock_name = [
-            dimg.project.name,
-            'cookbooks',
-            chef_cookbooks_stage ? 'chef_cookbooks_stage' : nil,
-            cookbooks_checksum
-          ].compact.join('.')
-
-          dimg.project.lock(lock_name, default_timeout: 120) do
-            @install_cookbooks ||= {}
-            @install_cookbooks[chef_cookbooks_stage] ||= begin
-              install_cookbooks(_cookbooks_path, chef_cookbooks_stage: chef_cookbooks_stage) unless _cookbooks_path.join('.created_at').exist? && !dimg.project.dev_mode?
-              true
-            end
-          end
-        end.join(*path)
+      def stage_attributes_raw(stage)
+        JSON.dump stage_attributes(stage)
       end
 
-      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      def install_stage_cookbooks(stage)
-        select_existing_paths = proc do |cookbook_path, paths|
-          paths.select { |from, _| cookbook_path.join(from).exist? }
-        end
+      def stage_cookbooks_checksum_path(stage)
+        dimg.build_path.join("#{builder_cookbook.checksum}.#{stage}.checksum")
+      end
 
-        common_paths = [['metadata.json', 'metadata.json']]
-
-        install_paths = Dir[cookbooks_vendor_path('*')]
-                        .map(&Pathname.method(:new))
-                        .map do |cookbook_path|
-          cookbook_name = File.basename cookbook_path
-          is_project = (cookbook_name == project_name)
-          is_mdapp = cookbook_name.start_with? 'mdapp-'
-          mdapp_enabled = is_mdapp && enabled_modules.include?(cookbook_name)
-
-          paths = if is_project
-                    common_dapp_paths = select_existing_paths.call(cookbook_path, [
-                                                                     *common_paths,
-                                                                     ["files/#{stage}/common", 'files/default'],
-                                                                     ["templates/#{stage}/common", 'templates/default'],
-                                                                     *enabled_recipes.flat_map do |recipe|
-                                                                       [["files/#{stage}/#{recipe}", 'files/default'],
-                                                                        ["templates/#{stage}/#{recipe}", 'templates/default']]
-                                                                     end
-                                                                   ])
-
-                    recipe_paths = enabled_recipes.map { |recipe| ["recipes/#{stage}/#{recipe}.rb", "recipes/#{recipe}.rb"] }
-                                                  .select { |from, _| cookbook_path.join(from).exist? }
-                    if recipe_paths.any?
-                      [*recipe_paths, *common_dapp_paths]
-                    else
-                      [nil, *common_dapp_paths]
-                    end
-                  elsif is_mdapp && mdapp_enabled
-                    common_mdapp_paths = select_existing_paths.call(cookbook_path, [
-                                                                      *common_paths,
-                                                                      ["files/#{stage}", 'files/default'],
-                                                                      ['files/common', 'files/default'],
-                                                                      ["templates/#{stage}", 'templates/default'],
-                                                                      ['templates/common', 'templates/default'],
-                                                                      ["attributes/#{stage}.rb", "attributes/#{stage}.rb"],
-                                                                      ['attributes/common.rb', 'attributes/common.rb']
-                                                                    ])
-
-                    recipe_path = "recipes/#{stage}.rb"
-                    if cookbook_path.join(recipe_path).exist?
-                      [[recipe_path, recipe_path], *common_mdapp_paths]
-                    else
-                      [nil, *common_mdapp_paths]
-                    end
-                  elsif !is_mdapp
-                    [['.', '.']]
-                  end
-
-          [cookbook_path, paths] if paths && paths.any?
-        end.compact
-
-        _stage_cookbooks_path(stage).mkpath
-        install_paths.each do |cookbook_path, paths|
-          cookbook = cookbook_path.basename.to_s
-
-          paths.each do |from, to|
-            if from.nil?
-              to_path = _stage_cookbooks_path(stage).join(cookbook, 'recipes/void.rb')
-              to_path.parent.mkpath
-              FileUtils.touch to_path
-            else
-              from_path = cookbook_path.join(from)
-              to_path = _stage_cookbooks_path(stage).join(cookbook, to)
-              if from_path.directory? && to_path.exist?
-                Dir[from_path.join('**/*')]
-                  .map(&Pathname.method(:new))
-                  .each do |from_subpath|
-                    to_subpath = to_path.join(from_subpath.relative_path_from(from_path))
-                    raise Error, code: :stage_path_overlap,
-                                 data: { stage: stage,
-                                         cookbook: cookbook,
-                                         from: from_subpath.relative_path_from(cookbook_path),
-                                         to: to_subpath.relative_path_from(_stage_cookbooks_path(stage).join(cookbook)) } if to_subpath.exist?
-
-                    to_subpath.parent.mkpath
-                    FileUtils.cp_r from_subpath, to_subpath
-                  end
-              else
-                to_path.parent.mkpath
-                FileUtils.cp_r from_path, to_path
-              end
-            end
+      def stage_cookbooks_checksum(stage)
+        if stage_cookbooks_checksum_path(stage).exist?
+          stage_cookbooks_checksum_path(stage).read.strip
+        else
+          checksum = builder_cookbook.stage_checksum(stage)
+
+          stage_cookbooks_checksum_path(stage).tap do |path|
+            path.parent.mkpath
+            path.write "#{checksum}\n"
           end
+
+          checksum
         end
       end
-      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
       # rubocop:disable Metrics/AbcSize
       def stage_cookbooks_runlist(stage)
@@ -463,24 +136,25 @@ module Dapp
             "#{cookbook}::#{entrypoint}"
           end
 
-          enabled_modules.map do |cookbook|
-            if stage_enabled_modules(stage).include? cookbook
+          builder_cookbook.enabled_modules.map do |cookbook|
+            if builder_cookbook.stage_enabled_modules(stage).include? cookbook
               [cookbook, stage]
             else
               [cookbook, nil]
             end
-          end.tap { |entries| res.concat entries }
+          end.tap {|entries| res.concat entries}
 
-          stage_enabled_recipes(stage).map { |recipe| [project_name, recipe] }
-                                      .tap do |entries|
+          builder_cookbook.stage_enabled_recipes(stage)
+            .map {|recipe| [builder_cookbook.name, recipe]}
+            .tap do |entries|
             if entries.any?
               res.concat entries
             else
-              res << [project_name, nil]
+              res << [builder_cookbook.name, nil]
             end
           end
 
-          if res.all? { |_, entrypoint| entrypoint.nil? }
+          if res.all? {|_, entrypoint| entrypoint.nil?}
             []
           else
             res.map(&format_entry)
@@ -493,55 +167,40 @@ module Dapp
         stage_cookbooks_runlist(stage).empty?
       end
 
-      def stage_entry_exist?(stage, cookbook, entrypoint)
-        stage_cookbooks_path(stage, cookbook, 'recipes', "#{entrypoint}.rb").exist?
-      end
-
-      def _stage_cookbooks_path(stage)
-        stage_build_path(stage, 'cookbooks')
-      end
-
-      def stage_cookbooks_path(stage, *path)
-        _stage_cookbooks_path(stage).tap do |_cookbooks_path|
-          @install_stage_cookbooks ||= {}
-          @install_stage_cookbooks[stage] ||= true.tap { install_stage_cookbooks(stage) }
-        end.join(*path)
-      end
-
       def install_chef_solo_stage_config(stage)
         @install_chef_solo_stage_config ||= {}
         @install_chef_solo_stage_config[stage] ||= true.tap do
-          stage_build_path(stage, 'config.rb').write [
+          stage_build_path(stage).join('config.rb').write [
             "file_cache_path \"/.dapp/chef/cache\"\n",
-            "cookbook_path \"#{container_stage_build_path(stage, 'cookbooks')}\"\n"
+            "cookbook_path \"#{container_stage_build_path(stage).join('cookbooks')}\"\n"
           ].join
         end
       end
 
-      def container_stage_config_path(stage, *path)
+      def container_stage_config_path(stage)
         install_chef_solo_stage_config(stage)
-        container_stage_build_path(stage, 'config.rb', *path)
+        container_stage_build_path(stage).join('config.rb')
       end
 
       def install_json_attributes(stage)
         @install_json_attributes ||= {}
         @install_json_attributes[stage] ||= true.tap do
-          stage_build_path(stage, 'attributes.json').write "#{stage_attributes_raw(stage)}\n"
+          stage_build_path(stage).join('attributes.json').write "#{stage_attributes_raw(stage)}\n"
         end
       end
 
-      def container_stage_json_attributes_path(stage, *path)
+      def container_stage_json_attributes_path(stage)
         install_json_attributes(stage)
-        container_stage_build_path(stage, 'attributes.json', *path)
+        container_stage_build_path(stage).join('attributes.json')
       end
 
-      def stage_build_path(stage, *path)
-        dimg.tmp_path(dimg.config._name, stage).join(*path)
+      def stage_build_path(stage)
+        dimg.tmp_path(dimg.config._name).join(stage.to_s)
       end
 
-      def container_stage_build_path(_stage, *path)
-        path.compact.map(&:to_s).inject(Pathname.new('/.dapp/chef/build'), &:+)
+      def container_stage_build_path(_stage)
+        Pathname.new('/.dapp/chef/build')
       end
-    end
-  end
-end
+    end # Chef
+  end # Builder
+end # Dapp