dapp 0.5.13 → 0.6.0

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

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

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

@@ -0,0 +1,27 @@
+module Dapp
+  module Build
+    module Stage
+      module SetupGroup
+        # GAPreSetupPatchDependencies
+        class GAPreSetupPatchDependencies < GADependenciesBase
+          include Mod::Group
+
+          def initialize(application, next_stage)
+            @prev_stage = BeforeSetup.new(application, self)
+            super
+          end
+
+          def dependencies
+            [setup_dependencies_files_checksum, application.builder.setup_checksum]
+          end
+
+          private
+
+          def setup_dependencies_files_checksum
+            @setup_files_checksum ||= dependencies_files_checksum(application.config._setup_dependencies)
+          end
+        end # GAPreSetupPatchDependencies
+      end
+    end # Stage
+  end # Build
+end # Dapp

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

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

data/lib/dapp/builder/base.rb

@@ -8,27 +8,30 @@ module Dapp
         @application = application
       end
 
-      def infra_install?
+      def before_application_export
+      end
+
+      def before_install?
         false
       end
 
-      def infra_install(_image)
+      def before_install(_image)
         raise
       end
 
-      def infra_install_checksum
+      def before_install_checksum
         raise
       end
 
-      def infra_setup?
+      def before_setup?
         false
       end
 
-      def infra_setup(_image)
+      def before_setup(_image)
         raise
       end
 
-      def infra_setup_checksum
+      def before_setup_checksum
         raise
       end
 

data/lib/dapp/builder/chef.rb

@@ -11,18 +11,28 @@ module Dapp
 
       DEFAULT_CHEFDK_IMAGE = 'dappdeps/chefdk:0.17.3-1'.freeze # TODO: config, DSL, DEFAULT_CHEFDK_IMAGE
 
-      [:infra_install, :infra_setup, :install, :setup].each do |stage|
-        define_method("#{stage}_checksum") do
-          application.hashsum [stage_cookbooks_checksum(stage), *stage_cookbooks_runlist(stage)]
+      def before_application_export
+        super
+
+        %i(before_install install before_setup setup chef_cookbooks).each do |stage|
+          raise ::Dapp::Error::Application, code: :cookbooks_stage_checksum_not_caclculated,
+                                            data: { stage: stage } unless stage_cookbooks_checksum_path(stage).exist?
         end
+      end
+
+      %i(before_install install before_setup setup).each do |stage|
+        define_method("#{stage}_checksum") { stage_cookbooks_checksum(stage) }
 
         define_method("#{stage}?") { !stage_empty?(stage) }
 
-        define_method("#{stage}") do |image|
+        define_method(stage.to_s) do |image|
           unless stage_empty?(stage)
             image.add_volumes_from(chefdk_container)
+            image.add_command 'export PATH=/.dapp/deps/chefdk/bin:$PATH',
+                              "export DAPP_BUILD_STAGE=#{stage}"
+
             image.add_volume "#{stage_build_path(stage)}:#{container_stage_build_path(stage)}:ro"
-            image.add_command ['/.dapp/deps/chefdk/bin/chef-solo',
+            image.add_command ['chef-solo',
                                '--legacy-mode',
                                "-c #{container_stage_config_path(stage)}",
                                "-o #{stage_cookbooks_runlist(stage).join(',')}"].join(' ')
@@ -35,10 +45,10 @@ module Dapp
       end
 
       def chef_cookbooks(image)
-        image.add_volume "#{cookbooks_vendor_path(chef_cookbooks_stage: true)}:#{application.container_dapp_path('chef_vendored_cookbooks')}"
+        image.add_volume "#{cookbooks_vendor_path}:#{application.container_dapp_path('chef_cookbooks')}"
         image.add_command(
           'mkdir -p /usr/share/dapp/chef_repo',
-          ["cp -a #{application.container_dapp_path('chef_vendored_cookbooks')} ",
+          ["cp -a #{application.container_dapp_path('chef_cookbooks')} ",
            '/usr/share/dapp/chef_repo/cookbooks'].join
         )
       end
@@ -78,11 +88,11 @@ module Dapp
       end
 
       def berksfile_lock_checksum
-        application.hashsum berksfile_lock_path.read if berksfile_lock_path.exist?
+        application.hashsum(berksfile_lock_path.read) if berksfile_lock_path.exist?
       end
 
       def stage_cookbooks_checksum_path(stage)
-        application.build_path("#{cookbooks_checksum}.#{stage}.checksum")
+        application.build_path.join("#{cookbooks_checksum}.#{stage}.checksum")
       end
 
       def stage_cookbooks_checksum(stage)
@@ -90,18 +100,28 @@ module Dapp
           stage_cookbooks_checksum_path(stage).read.strip
         else
           checksum = if stage == :chef_cookbooks
-                       cookbooks_checksum
+                       paths = Dir[cookbooks_vendor_path('**/*')].map(&Pathname.method(:new))
+
+                       application.hashsum [
+                         application.paths_content_hashsum(paths),
+                         *paths.map { |p| p.relative_path_from(cookbooks_vendor_path).to_s }.sort
+                       ]
                      else
                        paths = Dir[stage_cookbooks_path(stage, '**/*')].map(&Pathname.method(:new))
 
                        application.hashsum [
                          application.paths_content_hashsum(paths),
                          *paths.map { |p| p.relative_path_from(stage_cookbooks_path(stage)).to_s }.sort,
-                         stage == :infra_install ? chefdk_image : nil
+                         *enabled_modules,
+                         stage == :before_install ? chefdk_image : nil
                        ].compact
                      end
 
-          stage_cookbooks_checksum_path(stage).write "#{checksum}\n"
+          stage_cookbooks_checksum_path(stage).tap do |path|
+            path.parent.mkpath
+            path.write "#{checksum}\n"
+          end
+
           checksum
         end
       end
@@ -109,21 +129,20 @@ module Dapp
       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))
+                  .local_cookbooks
+                  .values
+                  .map { |cookbook| cookbook[:path] }
+                  .product(LOCAL_COOKBOOK_CHECKSUM_PATTERNS)
+                  .map { |cb, dir| Dir[cb.join(dir)] }
+                  .flatten
+                  .map(&Pathname.method(:new))
 
           application.hashsum [
             application.paths_content_hashsum(paths),
             *paths.map { |p| p.relative_path_from(berksfile.home_path).to_s }.sort,
-            berksfile_lock_checksum,
-            *enabled_recipes,
+            (berksfile_lock_checksum unless application.project.cli_options[:dev]),
             *enabled_modules
-          ]
+          ].compact
         end
       end
 
@@ -137,9 +156,9 @@ module Dapp
 
       def chefdk_container
         @chefdk_container ||= begin
-          if application.shellout("docker inspect #{chefdk_container_name}").exitstatus.nonzero?
-            application.log_secondary_process(application.t(code: 'process.chefdk_container_loading'), short: true) do
-              application.shellout(
+          if application.project.shellout("docker inspect #{chefdk_container_name}").exitstatus.nonzero?
+            application.project.log_secondary_process(application.project.t(code: 'process.chefdk_loading'), short: true) do
+              application.project.shellout(
                 ['docker run',
                  '--restart=no',
                  "--name #{chefdk_container_name}",
@@ -148,91 +167,97 @@ module Dapp
               )
             end
           end
+
           chefdk_container_name
         end
       end
 
       # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      def install_cookbooks(dest_path, chef_cookbooks_stage: false)
+      def install_cookbooks
         volumes_from = chefdk_container
-        application.log_secondary_process(application.t(code: "process.#{chef_cookbooks_stage ? 'chef_cookbooks_stage_berks_vendor' : 'berks_vendor'}")) do
-          ssh_auth_socket_path = nil
-          ssh_auth_socket_path = Pathname.new(ENV['SSH_AUTH_SOCK']).expand_path if ENV['SSH_AUTH_SOCK'] && File.exist?(ENV['SSH_AUTH_SOCK'])
+        application.project.log_secondary_process(application.project.t(code: 'process.berks_vendor')) do
+          before_vendor_commands = [].tap do |commands|
+            unless application.project.cli_options[:dev]
+              commands.push(
+                ['if [ ! -f Berksfile.lock ] ; then ',
+                 'echo "Berksfile.lock not found" 1>&2 ; ',
+                 'exit 1 ; ',
+                 'fi'].join
+              )
+            end
+          end
 
-          before_berks_vendor = [
+          after_vendor_commands = [].tap do |commands|
+            if application.project.cli_options[:dev]
+              commands.push(
+                ["install -o #{Process.uid} -g #{Process.gid} --mode $(stat -c %a Berksfile.lock) ",
+                 "Berksfile.lock #{berksfile_lock_path}"].join
+              )
+            else
+              commands.push(
+                "export LOCKDIFF=$(diff -u1 Berksfile.lock #{berksfile_lock_path})",
+                ['if [ "$LOCKDIFF" != "" ] ; then ',
+                 'echo -e "Bad Berksfile.lock\n$LOCKDIFF" 1>&2 ; ',
+                 'exit 1 ; ',
+                 'fi'].join
+              )
+            end
+          end
+
+          vendor_commands = [
             'mkdir -p ~/.ssh',
             'echo "Host *" >> ~/.ssh/config',
             'echo "    StrictHostKeyChecking no" >> ~/.ssh/config',
-            ('if [ ! -f Berksfile.lock ] ; then echo "Berksfile.lock not found" 2>&2 ; exit 1 ; fi' unless chef_cookbooks_stage),
-            'if [ -f Berksfile.lock ] ; then cp -a Berksfile.lock /tmp/Berksfile.lock.orig ; fi'
-          ]
-
-          after_berks_vendor = []
-          if chef_cookbooks_stage
-            after_berks_vendor.concat [
-              'cp -a /tmp/Berksfile.lock.orig Berksfile.lock'
-            ]
-          else
-            after_berks_vendor.concat [
-              'export LOCKDIFF=$(diff -u0 Berksfile.lock /tmp/Berksfile.lock.orig)',
-              ['if [ "$LOCKDIFF" != "" ] ; then ',
-               'cp -a /tmp/Berksfile.lock.orig Berksfile.lock ; ',
-               'echo -e "Bad Berksfile.lock\n$LOCKDIFF" 1>&2 ; exit 1 ; fi'].join
-            ]
-          end
-
-          move_cookbooks = [
-            ["find /tmp/vendored_cookbooks -type d -exec bash -ec '",
+            *berksfile.local_cookbooks
+                      .values
+                      .map { |cookbook| "rsync --archive --relative #{cookbook[:path]} /tmp/local_cookbooks" },
+            "cd /tmp/local_cookbooks/#{berksfile_path.parent}",
+            *before_vendor_commands,
+            '/.dapp/deps/chefdk/bin/berks vendor /tmp/cookbooks',
+            *after_vendor_commands,
+            ["find /tmp/cookbooks -type d -exec bash -ec '",
              "install -o #{Process.uid} -g #{Process.gid} --mode $(stat -c %a {}) -d ",
-             "#{dest_path}/$(echo {} | sed -e \"s/^\\/tmp\\/vendored_cookbooks//\")' \\;"].join,
-            ["find /tmp/vendored_cookbooks -type f -exec bash -ec '",
+             "#{_cookbooks_vendor_path}/$(echo {} | sed -e \"s/^\\/tmp\\/cookbooks//\")' \\;"].join,
+            ["find /tmp/cookbooks -type f -exec bash -ec '",
              "install -o #{Process.uid} -g #{Process.gid} --mode $(stat -c %a {}) {} ",
-             "#{dest_path}/$(echo {} | sed -e \"s/\\/tmp\\/vendored_cookbooks//\")' \\;"].join
+             "#{_cookbooks_vendor_path}/$(echo {} | sed -e \"s/\\/tmp\\/cookbooks//\")' \\;"].join,
+            "install -o #{Process.uid} -g #{Process.gid} --mode 0644 <(date +%s.%N) #{_cookbooks_vendor_path.join('.created_at')}"
           ]
 
-          vendor_commands = [
-            *before_berks_vendor.compact,
-            "/.dapp/deps/chefdk/bin/berks vendor /tmp/vendored_cookbooks",
-            *after_berks_vendor.compact,
-            *move_cookbooks.compact
-          ]
-
-          application.shellout!(
+          application.project.shellout!(
             ['docker run --rm',
-             ("--volume #{ssh_auth_socket_path}:#{ssh_auth_socket_path}" if ssh_auth_socket_path),
-             "--volume #{dest_path.tap(&:mkpath)}:#{dest_path}",
+             "--volumes-from #{volumes_from}",
              *berksfile.local_cookbooks
                        .values
                        .map { |cookbook| "--volume #{cookbook[:path]}:#{cookbook[:path]}" },
-             "--volumes-from #{volumes_from}",
-             "--workdir #{berksfile_path.parent}",
-             ("--env SSH_AUTH_SOCK=#{ssh_auth_socket_path}" if ssh_auth_socket_path),
-             ('--env DAPP_CHEF_COOKBOOKS_VENDORING=1' if chef_cookbooks_stage),
-             "dappdeps/berksdeps:0.1.0 bash -ec '#{application.shellout_pack(vendor_commands.join(' && '))}'"].compact.join(' '),
-            log_verbose: application.log_verbose?
+             ("--volume #{application.project.ssh_auth_sock}:#{application.project.ssh_auth_sock}" if application.project.ssh_auth_sock),
+             "--volume #{_cookbooks_vendor_path.tap(&:mkpath)}:#{_cookbooks_vendor_path}",
+             ("--env SSH_AUTH_SOCK=#{application.project.ssh_auth_sock}" if application.project.ssh_auth_sock),
+             "dappdeps/berksdeps:0.1.0 bash -ec '#{application.project.shellout_pack(vendor_commands.join(' && '))}'"].compact.join(' '),
+            log_verbose: application.project.log_verbose?
           )
         end
       end
       # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
-      def _cookbooks_vendor_path(chef_cookbooks_stage: false)
-        application.tmp_path(
-          application.config._name,
-          ['cookbooks',
-           chef_cookbooks_stage ? 'chef_cookbooks_stage' : nil,
-           cookbooks_checksum].compact.join('.')
-        )
+      def _cookbooks_vendor_path
+        application.build_path.join('cookbooks', cookbooks_checksum)
       end
 
-      def cookbooks_vendor_path(*path, chef_cookbooks_stage: false)
-        _cookbooks_vendor_path(chef_cookbooks_stage: chef_cookbooks_stage).tap do |cookbooks_path|
-          install_cookbooks(cookbooks_path, chef_cookbooks_stage: chef_cookbooks_stage) unless cookbooks_path.exist?
+      def cookbooks_vendor_path(*path)
+        _cookbooks_vendor_path.tap do |cookbooks_path|
+          application.project.lock("#{application.config._basename}.cookbooks.#{cookbooks_checksum}", default_timeout: 120) do
+            @install_cookbooks ||= begin
+              install_cookbooks unless _cookbooks_vendor_path.join('.created_at').exist? && !application.project.cli_options[:dev]
+              true
+            end
+          end
         end.join(*path)
       end
 
       # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
       def install_stage_cookbooks(stage)
-        select_existing_paths = proc do |cookbook_path, paths|
+        select_existing_paths = ->(cookbook_path, paths) do
           paths.select { |from, _| cookbook_path.join(from).exist? }
         end
 
@@ -250,9 +275,8 @@ module Dapp
           mdapp_enabled = is_mdapp && enabled_modules.include?(mdapp_name)
 
           paths = if is_project
-                    recipe_paths = enabled_recipes
-                                   .map { |recipe| ["recipes/#{stage}/#{recipe}.rb", "recipes/#{recipe}.rb"] }
-                                   .select { |from, _| cookbook_path.join(from).exist? }
+                    recipe_paths = enabled_recipes.map { |recipe| ["recipes/#{stage}/#{recipe}.rb", "recipes/#{recipe}.rb"] }
+                                                  .select { |from, _| cookbook_path.join(from).exist? }
 
                     common_project_paths = select_existing_paths.call(
                       cookbook_path, [*common_paths,
@@ -279,7 +303,7 @@ module Dapp
                     else
                       [nil, *common_mdapp_paths]
                     end
-                  elsif !is_mdapp
+                  else
                     [['.', '.']]
                   end
 
@@ -328,41 +352,38 @@ module Dapp
         @stage_cookbooks_runlist[stage] ||= begin
           res = []
 
-          does_entry_exist = proc do |cookbook, entrypoint|
+          does_entry_exist = lambda do |cookbook, entrypoint|
             stage_cookbooks_path(stage, cookbook, 'recipes', "#{entrypoint}.rb").exist?
           end
 
-          format_entry = proc do |cookbook, entrypoint|
+          format_entry = lambda do |cookbook, entrypoint|
             entrypoint = 'void' if entrypoint.nil?
             "#{cookbook}::#{entrypoint}"
           end
 
-          enabled_modules
-            .map do |mod|
-              cookbook = "mdapp-#{mod}"
-              if does_entry_exist[cookbook, stage]
-                [cookbook, stage]
-              else
-                [cookbook, nil]
-              end
+          enabled_modules.map do |mod|
+            cookbook = "mdapp-#{mod}"
+            if does_entry_exist[cookbook, stage]
+              [cookbook, stage]
+            else
+              [cookbook, nil]
             end
-            .tap { |entries| res.concat entries }
-
-          enabled_recipes
-            .map { |recipe| [project_name, recipe] }
-            .select { |entry| does_entry_exist[*entry] }
-            .tap do |entries|
-              if entries.any?
-                res.concat entries
-              else
-                res << [project_name, nil]
-              end
+          end.tap { |entries| res.concat entries }
+
+          enabled_recipes.map { |recipe| [project_name, recipe] }
+                         .select { |entry| does_entry_exist[*entry] }
+                         .tap do |entries|
+            if entries.any?
+              res.concat entries
+            else
+              res << [project_name, nil]
             end
+          end
 
           if res.all? { |_, entrypoint| entrypoint.nil? }
             []
           else
-            res.map &format_entry
+            res.map(&format_entry)
           end
         end
       end
@@ -377,7 +398,7 @@ module Dapp
       end
 
       def stage_cookbooks_path(stage, *path)
-        _stage_cookbooks_path(stage).tap do |cookbooks_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)