dapp 0.18.5 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f192d0db959cd4bbe86c8ee764de426729e292f05f8887d2540c93d79c13369
-  data.tar.gz: c9869e3365e81c5b60ed6f7a8a6551feba1b3da8f2226afab49f5d43c18637be
+  metadata.gz: 2dccc0e1f4d0b7a91f69e715cf39b028b998a4872bb6835eb6ba77bee05ed991
+  data.tar.gz: 2ee85bb1d9906d705aabe8343982a4afc3ab0ba337875f2d031a8b53ce8eab4a
 SHA512:
-  metadata.gz: 3379f78551bebf688b5f8b74b92832dae9970b6b479af32427e693b1a64b4b1d9f456a383a0bad1a4d0cc086d8047f33cb00e59f7a09c06ee1fa78aac2866932
-  data.tar.gz: 72893404d6790aa820bf3b835a097fa9cca4d5f7346c3d874f0ad167114d1b79f3a397e1d38386dd127d232a0e60d06d4c28b53029deb683eaf56155d1989f48
+  metadata.gz: 490982b52706aae26ae42a827abf2bca667f80853ecf5a419dfbe5621b38b6d4cce2bf0e4ef703c0135182082cabb7485ecf48d7542d7189348248b1ac3d3dd9
+  data.tar.gz: 7aec1a9542c4f892c1f69a96884be15d4182817a8c74254450c1024db15b177ec7cb4a41c67441b41441891c35e7338f227cb4b96a6d06b8f85817890e41a1e3

data/lib/dapp/dapp/shellout/base.rb

@@ -50,6 +50,12 @@ module Dapp
           end
         end # << self
 
+        def shellout_cmd_should_succeed!(cmd)
+          return cmd.tap(&:error!)
+        rescue ::Mixlib::ShellOut::ShellCommandFailed => e
+          raise Error::Shellout, code: Helper::Trivia.class_to_lowercase(e.class), data: { stream: e.message }
+        end
+
         protected
 
         def _shellout_with_logging!(*args, verbose: false, quiet: true, time: false, **kwargs)

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

@@ -27,7 +27,7 @@ module Dapp
               no_lock = false
 
               dimg.dapp.lock("#{dimg.dapp.name}.image.#{image.name}") do
-                image.cache_reset
+                image.class.reset_image_inspect(image.name)
 
                 if image_should_be_locked?
                   yield

data/lib/dapp/dimg/builder/chef/cookbook.rb

@@ -187,8 +187,6 @@ module Dapp
                 Dir[from_path.join('**/*')]
                   .map(&Pathname.method(:new))
                   .each do |from_subpath|
-                    next if from_subpath.directory?
-
                     to_subpath = to_path.join(from_subpath.relative_path_from(from_path))
                     if to_subpath.exist?
                       raise(Error::Chef,

data/lib/dapp/dimg/cli/command/dimg/cleanup.rb

@@ -5,9 +5,7 @@ module Dapp::Dimg::CLI
         banner <<BANNER.freeze
 Usage:
 
-  dapp dimg cleanup [options] [DIMG ...]
-
-    DIMG                        Dapp image to process [default: *].
+  dapp dimg cleanup [options]
 
 Options:
 BANNER

data/lib/dapp/dimg/dapp/command/cleanup.rb

@@ -4,16 +4,9 @@ module Dapp
       module Command
         module Cleanup
           def cleanup
-            lock("#{name}.images") do
-              log_step_with_indent(name) do
-                dapp_containers_flush
-                dapp_dangling_images_flush
-                remove_images_by_query([
-                  "#{host_docker} images",
-                  %(--format '{{if ne "#{stage_cache}" .Repository }}{{.Repository}}:{{.Tag}}{{ end }}'),
-                  %(-f "label=dapp=#{stage_dapp_label}")
-                ].join(' ')) # FIXME: negative filter is not currently supported by the Docker CLI
-              end
+            log_step_with_indent(:cleanup) do
+              dapp_containers_flush
+              dapp_dangling_images_flush
             end
           end
         end

data/lib/dapp/dimg/dapp/command/common.rb

@@ -5,47 +5,109 @@ module Dapp
         module Common
           protected
 
-          def dapp_images_names
-            shellout!(%(#{host_docker} images --format="{{.Repository}}:{{.Tag}}" #{stage_cache})).stdout.lines.map(&:strip)
+          def dapp_project_image_labels(image_id)
+            dapp_project_image_inspect(image_id)['Config']['Labels']
           end
 
-          def dapp_images_ids
-            shellout!(%(#{host_docker} images #{stage_cache} -q --no-trunc)).stdout.lines.map(&:strip)
+          def dapp_project_image_inspect(image_id_or_name)
+            return {} unless dapp_project_image_exist?(image_id_or_name)
+
+            dapp_project_images.find { |img| [img[:name], img[:id]].include?(image_id_or_name) }[:inspect] ||= begin
+              cmd = shellout!("#{::Dapp::Dapp.host_docker} inspect --type=image #{image_id_or_name}")
+              Array(JSON.parse(cmd.stdout.strip)).first || {}
+            end
+          end
+
+          def dapp_project_image_exist?(image_id_or_name)
+            dapp_project_images.any? { |img| [img[:name], img[:id]].include?(image_id_or_name) }
+          end
+
+          def dapp_project_images_ids
+            dapp_project_images.map { |img| img[:id] }
+          end
+
+          def dapp_project_dangling_images
+            dapp_project_images.select { |img| project_dangling_image?(img) }
+          end
+
+          def project_dangling_image?(image)
+            image[:name] == '<none>:<none>'
+          end
+
+          def dapp_project_images
+            @dapp_project_images ||= [].tap do |images|
+              shellout!(%(#{host_docker} images --format="{{.ID}};{{.Repository}}:{{.Tag}};{{.CreatedAt}}" -f "label=dapp" #{stage_cache} --no-trunc))
+                  .stdout
+                  .lines
+                  .map(&:strip)
+                  .each do |l|
+                id, name, created_at = l.split(';')
+                images << { id: id, name: name, created_at: Time.parse(created_at) }
+              end
+            end
+          end
+
+          def dapp_project_containers_flush
+            remove_containers_by_query(%(#{host_docker} ps -a -f "label=dapp" -f "name=#{container_name_prefix}" -q --no-trunc))
+          end
+
+          def dapp_project_dangling_images_flush
+            remove_project_images(dapp_project_dangling_images.map { |img| img[:id] })
+          end
+
+          def remove_project_images(images_ids_or_names)
+            images_ids_or_names = convert_to_project_images_names(images_ids_or_names)
+            update_project_images(images_ids_or_names)
+            remove_images(images_ids_or_names)
+          end
+
+          def update_project_images(images_ids_or_names)
+            dapp_project_images.delete_if do |img|
+              images_ids_or_names.include?(img[:id]) || images_ids_or_names.include?(img[:name])
+            end
+          end
+
+          def convert_to_project_images_names(images_ids_or_names)
+            dapp_project_images.each_with_object([]) do |image, images|
+              if images_ids_or_names.include?(image[:id]) || images_ids_or_names.include?(image[:name])
+                images << (project_dangling_image?(image) ? image[:id] : image[:name])
+              end
+            end
           end
 
           def dapp_containers_flush
-            remove_containers_by_query(%(#{host_docker} ps -a -f "label=dapp" -f "name=#{container_name_prefix}" -q), force: true)
+            remove_containers_by_query(%(#{host_docker} ps -a -f "label=dapp" -q --no-trunc))
           end
 
           def dapp_dangling_images_flush
-            remove_images_by_query(%(#{host_docker} images -f "dangling=true" -f "label=dapp=#{stage_dapp_label}" -q), force: true)
+            remove_images_by_query(%(#{host_docker} images -f "dangling=true" -f "label=dapp" -q --no-trunc))
           end
 
-          def remove_images_by_query(images_query, force: false)
-            with_subquery(images_query) { |ids| remove_images(ids, force: force) }
+          def remove_images_by_query(images_query)
+            with_subquery(images_query) { |ids| remove_images(ids) }
           end
 
-          def remove_images(ids, force: false)
-            ids.uniq!
-            check_user_containers!(ids) unless force
-            remove_base("#{host_docker} rmi%{force_option} %{ids}", ids, force: force)
+          def remove_images(images_ids_or_names)
+            images_ids_or_names.uniq!
+            check_user_containers!(images_ids_or_names)
+            remove_base("#{host_docker} rmi%{force_option} %{ids}", images_ids_or_names, force: false)
           end
 
           def check_user_containers!(images_ids)
             return if images_ids.empty?
             log_step_with_indent(:'check user containers') do
-              run_command(%(#{host_docker} ps -a -q #{images_ids.uniq.map { |image_id| "--filter=ancestor=#{image_id}" }.join(' ')})).tap do |res|
+              run_command(%(#{host_docker} ps -a -q #{images_ids.uniq.map { |image_id| "--filter=ancestor=#{image_id}" }.join(' ')} --no-trunc)).tap do |res|
                 raise Error::Command, code: :user_containers_detected, data: { ids: res.stdout.strip } if res && !res.stdout.strip.empty? && !dry_run?
               end
             end
           end
 
-          def remove_containers_by_query(containers_query, force: false)
-            with_subquery(containers_query) { |ids| remove_containers(ids, force: force) }
+          def remove_containers_by_query(containers_query)
+            with_subquery(containers_query) { |ids| remove_containers(ids) }
           end
 
-          def remove_containers(ids, force: false)
-            remove_base("#{host_docker} rm%{force_option} %{ids}", ids.uniq, force: force)
+          def remove_containers(ids)
+            remove_base("#{host_docker} rm%{force_option} %{ids}", ids.uniq, force: true)
           end
 
           def remove_base(query_format, ids, force: false)
@@ -59,10 +121,6 @@ module Dapp
             yield(res)
           end
 
-          def image_labels(image_id)
-            Image::Stage.image_config_option(image_id: image_id, option: 'Labels') || {}
-          end
-
           def run_command(cmd)
             log(cmd) if log_verbose? || dry_run?
             shellout!(cmd) unless dry_run?

data/lib/dapp/dimg/dapp/command/mrproper.rb

@@ -6,36 +6,25 @@ module Dapp
           # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
           def mrproper
             log_step_with_indent(:mrproper) do
-              raise Error::Command, code: :mrproper_required_option unless proper_all? || proper_dev_mode_cache? || proper_cache_version?
-
-              dapp_dangling_images_flush
+              raise Error::Command, code: :mrproper_required_option if mrproper_command_without_any_option?
 
               if proper_all?
-                flush_by_label('dapp')
-                remove_build_dir
+                proper_all
               elsif proper_dev_mode_cache?
-                flush_by_label('dapp-dev-mode')
+                proper_dev_mode_cache
               elsif proper_cache_version?
-                log_proper_cache do
-                  proper_cache_images = proper_cache_all_images
-                  remove_images(dapp_images_by_label('dapp').select { |id| !proper_cache_images.include?(id) }.map(&:strip))
-                end
+                proper_cache_version
               end
+
+              dapp_dangling_images_flush
             end
           end
           # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
 
           protected
 
-          def flush_by_label(label)
-            log_step_with_indent(:containers) { dapp_containers_flush_by_label(label) }
-            log_step_with_indent(:images) { dapp_images_flush_by_label(label) }
-          end
-
-          def remove_build_dir
-            log_step_with_indent(:build_dir) { FileUtils.rm_rf(build_path) }
-          rescue ::Dapp::Error::Dapp => e
-            raise unless e.net_status[:code] == :dappfile_not_found
+          def mrproper_command_without_any_option?
+            !(proper_all? || proper_dev_mode_cache? || proper_cache_version?)
           end
 
           def proper_all?
@@ -46,34 +35,54 @@ module Dapp
             !!options[:proper_dev_mode_cache]
           end
 
-          def dapp_containers_flush_by_label(label)
-            remove_containers_by_query(%(#{host_docker} ps -a -f "label=#{label}" -q), force: true)
+          def proper_all
+            flush_by_label('dapp')
+            remove_build_dir
           end
 
-          def dapp_dangling_images_flush_by_label(label)
-            remove_images_by_query(%(#{host_docker} images -f "dangling=true" -f "label=#{label}" -q), force: true)
+          def remove_build_dir
+            build_path.tap { |p| log_step_with_indent(:build_dir) { FileUtils.rm_rf(p) } }
+          rescue ::Dapp::Error::Dapp => e
+            raise unless e.net_status[:code] == :dappfile_not_found
+          end
+
+          def proper_dev_mode_cache
+            flush_by_label('dapp-dev-mode')
+          end
+
+          def flush_by_label(label)
+            log_step_with_indent(:containers) { dapp_containers_flush_by_label(label) }
+            log_step_with_indent(:images) { dapp_images_flush_by_label(label) }
+          end
+
+          def dapp_containers_flush_by_label(label)
+            remove_containers_by_query(%(#{host_docker} ps -a -f "label=dapp" -f "label=#{label}" -q --no-trunc))
           end
 
           def dapp_images_flush_by_label(label)
-            dapp_dangling_images_flush_by_label(label)
-            remove_images(dapp_images_by_label(label), force: true)
+            remove_images(dapp_images_names_by_label(label))
           end
 
-          def dapp_images_by_label(label)
-            @dapp_images ||= begin
-              shellout!(%(#{host_docker} images -f "dangling=false" --format="{{.Repository}}:{{.Tag}}" -f "label=#{label}"))
-                .stdout
-                .lines
-                .map(&:strip)
+          def proper_cache_version
+            log_proper_cache do
+              proper_cache_all_images_names.tap do |proper_cache_images|
+                remove_images(dapp_images_names_by_label('dapp').select { |image_name| !proper_cache_images.include?(image_name) })
+              end
             end
           end
 
-          def proper_cache_all_images
-            shellout!([
-              "#{host_docker} images",
-              '--format="{{.Repository}}:{{.Tag}}"',
-              %(-f "label=dapp-cache-version=#{::Dapp::BUILD_CACHE_VERSION}" -f "dangling=false")
-            ].join(' ')).stdout.lines.map(&:strip)
+          def proper_cache_all_images_names
+            shellout!(%(#{host_docker} images --format="{{.Repository}}:{{.Tag}}" -f "dangling=false" -f "label=dapp" -f "label=dapp-cache-version=#{::Dapp::BUILD_CACHE_VERSION}"))
+              .stdout
+              .lines
+              .map(&:strip)
+          end
+
+          def dapp_images_names_by_label(label)
+            shellout!(%(#{host_docker} images --format="{{.Repository}}:{{.Tag}}" -f "dangling=false" -f "label=dapp" -f "label=#{label}"))
+              .stdout
+              .lines
+              .map(&:strip)
           end
         end
       end

data/lib/dapp/dimg/dapp/command/stages/cleanup_local.rb

@@ -8,7 +8,7 @@ module Dapp
               lock_repo(option_repo, readonly: true) do
                 raise Error::Command, code: :stages_cleanup_required_option unless stages_cleanup_option?
 
-                dapp_containers_flush
+                dapp_project_containers_flush
 
                 proper_cache           if proper_cache_version?
                 stages_cleanup_by_repo if proper_repo_cache?
@@ -22,121 +22,95 @@ module Dapp
               log_proper_cache do
                 lock("#{name}.images") do
                   log_step_with_indent(name) do
-                    remove_images(dapp_images_names.select { |image_name| !actual_cache_images.include?(image_name) })
+                    remove_project_images(dapp_project_images_ids.select { |image_id| !actual_cache_project_images_ids.include?(image_id) })
                   end
                 end
               end
             end
 
+            def actual_cache_project_images_ids
+              @actual_cache_project_images_ids ||= begin
+                shellout!(%(#{host_docker} images -f "label=dapp" -f "label=dapp-cache-version=#{::Dapp::BUILD_CACHE_VERSION}" #{stage_cache} -q --no-trunc))
+                  .stdout
+                  .lines
+                  .map(&:strip)
+              end
+            end
+
             def stages_cleanup_by_repo
               registry = registry(option_repo)
               repo_dimgs = repo_dimgs_images(registry)
 
               lock("#{name}.images") do
                 log_step_with_indent(name) do
-                  dapp_dangling_images_flush
-                  dimgs, stages = dapp_images_hash.partition { |_, image_spec| repo_dimgs.values.include?(image_spec[:id]) }.map(&:to_h)
-                  dimgs.each { |_, dimg_spec| except_image_with_parents(dimg_spec[:id], stages) }
+                  dapp_project_dangling_images_flush
+
+                  dimgs, stages = dapp_project_images.partition { |image| repo_dimgs.values.include?(image[:id]) }
+                  dimgs.each { |dimg_image| except_dapp_project_image_with_parents(dimg_image[:id], stages) }
 
                   # Удаление только образов старше 2ч
-                  stages.delete_if do |_, stage_spec|
-                    Time.now - stage_spec[:created_at] < 2*60*60
+                  stages.delete_if do |stage_image|
+                    Time.now - stage_image[:created_at] < 2*60*60
                   end
 
-                  remove_images(stages.keys)
+                  remove_project_images(stages.map { |image| image[:id]} )
                 end
               end
             end
 
-            def repo_dimgs_images(registry)
-              repo_dimgs_and_cache(registry).first
-            end
-
-            def actual_cache_images
-              @actual_cache_images ||= begin
-                shellout!([
-                  "#{host_docker} images",
-                  '--format="{{.Repository}}:{{.Tag}}"',
-                  %(-f "label=dapp-cache-version=#{::Dapp::BUILD_CACHE_VERSION}"),
-                  stage_cache
-                ].join(' ')).stdout.lines.map(&:strip)
-              end
-            end
-
-            def dapp_images_hash
-              shellout!(%(#{host_docker} images --format "{{.Repository}}:{{.Tag}};{{.ID}};{{.CreatedAt}}" --no-trunc #{stage_cache}))
-                .stdout.lines.map do |line|
-                  name, id, created_at = line.strip.split(';', 3)
-                  [name, {name: name, id: id, created_at: Time.parse(created_at)}]
-                end.to_h
-            end
-
-            def except_image_with_parents(image_id, stages)
-              if image_exist?(image_id)
-                image_dapp_artifacts_label(image_id).each { |aiid| except_image_with_parents(aiid, stages) }
+            def except_dapp_project_image_with_parents(image_id, stages)
+              if dapp_project_image_exist?(image_id)
+                dapp_project_image_artifacts_ids_in_labels(image_id).each { |aiid| except_dapp_project_image_with_parents(aiid, stages) }
                 iid = image_id
                 loop do
-                  stages.delete_if { |_, stage_spec| stage_spec[:id] == iid }
-                  break if (iid = image_parent(iid)).empty?
+                  stages.delete_if { |stage_image| stage_image[:id] == iid }
+                  break if (iid = dapp_project_image_parent_id(iid)).nil?
                 end
               else
-                stages.delete_if { |_, stage_spec| stage_spec[:id] == image_id }
+                stages.delete_if { |stage_image| stage_image[:id] == image_id }
               end
             end
 
-            def image_exist?(image_id)
-              shellout!(%(#{host_docker} inspect #{image_id}))
-              true
-            rescue ::Dapp::Error::Shellout
-              false
-            end
-
-            def image_dapp_artifacts_label(image_id)
-              select_dapp_artifacts_ids(::Dapp::Dimg::Image::Docker.image_config_option(image_id: image_id, option: 'Labels') || {})
-            end
-
-            def image_parent(image_id)
-              shellout!(%(#{host_docker} inspect -f {{.Parent}} #{image_id})).stdout.strip
+            def dapp_project_image_artifacts_ids_in_labels(image_id)
+              select_dapp_artifacts_ids(dapp_project_image_labels(image_id))
             end
 
             def proper_git_commit
               log_proper_git_commit do
-                unproper_images_names = []
-                dapp_images_detailed.each do |_, attrs|
-                  attrs['Config']['Labels'].each do |repo_name, commit|
-                    next if (repo = dapp_git_repositories[repo_name]).nil?
-                    unproper_images_names.concat(image_hierarchy_by_id(attrs['Id'])) unless repo.commit_exists?(commit)
-                  end
-                end
-                remove_images(unproper_images_names.uniq)
-              end
-            end
-
-            def dapp_images_detailed
-              @dapp_images_detailed ||= {}.tap do |images|
-                dapp_images_names.each do |image_name|
-                  shellout!(%(#{host_docker} inspect --format='{{json .}}' #{image_name})).stdout.strip.tap do |output|
-                    images[image_name] = output == 'null' ? {} : JSON.parse(output)
+                lock("#{name}.images") do
+                  dapp_project_dangling_images_flush
+
+                  unproper_images_ids = []
+                  dapp_project_images_ids.each do |image_id|
+                    dapp_project_image_labels(image_id).each do |repo_name, commit|
+                      next if (repo = dapp_git_repositories[repo_name]).nil?
+                      unproper_images_ids.concat(dapp_project_image_hierarchy(image_id)) unless repo.commit_exists?(commit)
+                    end
                   end
+                  remove_project_images(unproper_images_ids)
                 end
               end
             end
 
-            def image_hierarchy_by_id(image_id)
+            def dapp_project_image_hierarchy(image_id)
               hierarchy = []
               iids = [image_id]
 
               loop do
-                hierarchy.concat(dapp_images_detailed.map { |name, attrs| name if iids.include?(attrs['Id']) }.compact)
+                hierarchy.concat(dapp_project_images_ids.select { |image_id| iids.include?(image_id) })
                 break if begin
                   iids.map! do |iid|
-                    dapp_images_detailed.map { |_, attrs| attrs['Id'] if attrs['Parent'] == iid }.compact
+                    dapp_project_images_ids.select { |image_id| dapp_project_image_parent_id(image_id) == iid }
                   end.flatten!.empty?
                 end
               end
 
               hierarchy
             end
+
+            def dapp_project_image_parent_id(image_id)
+              dapp_project_image_inspect(image_id)['Parent']
+            end
           end
         end
       end

data/lib/dapp/dimg/dapp/command/stages/cleanup_repo.rb

@@ -8,8 +8,10 @@ module Dapp
               lock_repo(repo = option_repo) do
                 raise Error::Command, code: :stages_cleanup_required_option unless stages_cleanup_option?
 
-                registry = registry(repo)
-                repo_dimgs, repo_stages = repo_dimgs_and_cache(registry)
+                registry    = registry(repo)
+                repo_dimgs  = repo_dimgs_images(registry)
+                repo_stages = repo_stages_images(registry)
+
                 repo_stages.delete_if { |_, siid| repo_dimgs.values.include?(siid) } # ignoring stages with dimgs ids (v2)
 
                 proper_repo_cache(registry, repo_stages)               if proper_cache_version?
@@ -31,7 +33,7 @@ module Dapp
             end
 
             def repo_stages_cleanup(registry, repo_dimgs, repo_stages)
-              log_step_with_indent(repo) do
+              log_step_with_indent(option_repo) do
                 repo_dimgs.each { |image_tag, image_id| clear_repo_stages(registry, repo_stages, image_tag, image_id) }
                 repo_stages.keys.each { |image_tag| delete_repo_image(registry, image_tag) }
               end
@@ -79,7 +81,7 @@ module Dapp
             end
 
             def repo_dapp_dappstage_images_detailed(registry)
-              @repo_dapp_images_detailed ||= begin
+              @repo_dapp_dappstage_images_detailed ||= begin
                 registry.tags.map do |tag|
                   next unless tag.start_with?('dimgstage')
 

data/lib/dapp/dimg/dapp/command/stages/common.rb

@@ -11,18 +11,30 @@ module Dapp
               ::Dapp::Dimg::DockerRegistry.new(repo)
             end
 
-            def repo_dimgs_and_cache(registry)
-              format = proc do |arr|
-                arr.map do |tag|
-                  if (id = registry.image_id(tag)).nil?
-                    log_warning(desc: { code: 'tag_ignored', data: { tag: tag } })
-                  else
-                    [tag, id]
-                  end
-                end.compact.to_h
+            def repo_dimgs_images(registry)
+              repo_dimgs_and_stages_images(registry)[:dimgs]
+            end
+
+            def repo_stages_images(registry)
+              repo_dimgs_and_stages_images(registry)[:stages]
+            end
+
+            def repo_dimgs_and_stages_images(registry)
+              @repo_dimgs_and_cache_names ||= {}.tap do |images|
+                format = proc do |arr|
+                  arr.map do |tag|
+                    if (id = registry.image_id(tag)).nil?
+                      log_warning(desc: { code: 'tag_ignored', data: { tag: tag } })
+                    else
+                      [tag, id]
+                    end
+                  end.compact.to_h
+                end
+                dimgs, stages = registry_tags(registry).partition { |tag| !tag.start_with?('dimgstage') }
+
+                images[:dimgs] = format.call(dimgs)
+                images[:stages] = format.call(stages)
               end
-              dimgs, stages = registry.tags.partition { |tag| !tag.start_with?('dimgstage') }
-              [format.call(dimgs), format.call(stages)]
             end
 
             def registry_tags(registry)
@@ -41,8 +53,8 @@ module Dapp
               end
             end
 
-            def select_dapp_artifacts_ids(hash)
-              hash.select { |k, _v| k.start_with?('dapp-artifact') }.values
+            def select_dapp_artifacts_ids(labels)
+              labels.select { |k, _v| k.start_with?('dapp-artifact') }.values
             end
 
             def dapp_git_repositories

data/lib/dapp/dimg/dapp/command/stages/flush_local.rb

@@ -7,9 +7,9 @@ module Dapp
             def stages_flush_local
               lock("#{name}.images") do
                 log_step_with_indent(name) do
-                  dapp_containers_flush
-                  dapp_dangling_images_flush
-                  remove_images(dapp_images_names)
+                  dapp_project_containers_flush
+                  dapp_project_dangling_images_flush
+                  remove_project_images(dapp_project_images_ids)
                 end
               end
             end

data/lib/dapp/dimg/dapp/command/stages/flush_repo.rb

@@ -7,8 +7,10 @@ module Dapp
             def stages_flush_repo
               lock_repo(option_repo) do
                 log_step_with_indent(option_repo) do
-                  registry = registry(option_repo)
-                  repo_dimgs, repo_stages = repo_dimgs_and_cache(registry)
+                  registry    = registry(option_repo)
+                  repo_dimgs  = repo_dimgs_images(registry)
+                  repo_stages = repo_stages_images(registry)
+
                   repo_dimgs.merge(repo_stages).keys.each { |image_tag| delete_repo_image(registry, image_tag) }
                 end
               end

data/lib/dapp/dimg/dimg.rb

@@ -83,7 +83,8 @@ module Dapp
           dapp.log_state(image_name, state: dapp.t(code: 'state.push'), styles: { status: :success })
         else
           dapp.lock("image.#{hashsum image_name}") do
-            ::Dapp::Dimg::Image::Stage.cache.delete(image_name)
+            ::Dapp::Dimg::Image::Docker.reset_image_inspect(image_name)
+
             dapp.log_process(image_name, process: dapp.t(code: 'status.process.pushing')) do
               image.export!(image_name)
             end
@@ -97,7 +98,8 @@ module Dapp
             begin
               image_name = format(format, repo: repo, signature: image.name.split(':').last)
               import_base!(image, image_name)
-            rescue ::Dapp::Error::Shellout
+            rescue ::Dapp::Error::Shellout => e
+              dapp.log_info ::Dapp::Helper::NetStatus.message(e)
               next
             end
             break unless dapp.pull_all_stages?

data/lib/dapp/dimg/git_repo/base.rb

@@ -25,9 +25,9 @@ module Dapp
         # FIXME: Лучше сейчас убрать фильтрацию, а добавить ее когда наберется достаточно
         # FIXME: примеров использования.
 
-        def patches(from, to, exclude_paths: [], **kwargs)
+        def patches(from, to, paths: [], exclude_paths: [], **kwargs)
           diff(from, to, **kwargs).patches.select do |patch|
-            !exclude_paths.any? { |p| check_path?(patch.delta.new_file[:path], p) }
+            !ignore_path?(patch.delta.new_file[:path], paths: paths, exclude_paths: exclude_paths)
           end
         end
 
@@ -35,15 +35,7 @@ module Dapp
           [].tap do |entries|
             lookup_commit(commit).tree.walk(:preorder) do |root, entry|
               fullpath = File.join(root, entry[:name]).reverse.chomp('/').reverse
-
-              is_exclude_path = exclude_paths.any? { |p| check_path?(fullpath, p) }
-              is_include_path = begin
-                paths.empty? ||
-                  paths.any? { |p| check_path?(fullpath, p) || check_subpath?(fullpath, p) }
-              end
-
-              next false if is_exclude_path || !is_include_path
-
+              next if entry[:type] == :tree || ignore_path?(fullpath, paths: paths, exclude_paths: exclude_paths)
               entries << [root, entry]
             end
           end
@@ -106,25 +98,23 @@ module Dapp
 
         private
 
-        def check_path?(path, format)
-          path_checker(path) do |checking_path|
-            File.fnmatch(format, checking_path)
+        def ignore_path?(path, paths: [], exclude_paths: [])
+          is_exclude_path = exclude_paths.any? { |p| check_path?(path, p) }
+          is_include_path = begin
+            paths.empty? ||
+                paths.any? { |p| File.fnmatch?(p, path) || File.fnmatch?(File.join(p, '**'), path) }
           end
-        end
 
-        def check_subpath?(path, format)
-          path_checker(format) do |checking_path|
-            File.fnmatch(checking_path, path)
-          end
+          is_exclude_path || !is_include_path
         end
 
-        def path_checker(path)
+        def check_path?(path, format)
           path_parts = path.split('/')
           checking_path = nil
 
           until path_parts.empty?
             checking_path = [checking_path, path_parts.shift].compact.join('/')
-            return true if yield checking_path
+            return true if File.fnmatch(format, checking_path)
           end
           false
         end

data/lib/dapp/dimg/git_repo/remote.rb

@@ -16,7 +16,7 @@ module Dapp
               end
 
               Rugged::Repository.clone_at(url, path.to_s, bare: true, credentials: _rugged_credentials)
-            rescue Rugged::NetworkError, Rugged::SslError => e
+            rescue Rugged::NetworkError, Rugged::SslError, Rugged::OSError => e
               raise Error::Rugged, code: :rugged_remote_error, data: { message: e.message, url: url }
             end
           end unless path.directory?

data/lib/dapp/dimg/image/docker.rb

@@ -27,14 +27,13 @@ module Dapp
         end
 
         def id
-          cache[:id]
+          self.class.image_inspect(self.name)["Id"]
         end
 
         def untag!
           raise Error::Build, code: :image_already_untagged, data: { name: name } unless tagged?
           dapp.shellout!("#{dapp.host_docker} rmi #{name}")
-          self.class.image_config_delete(id)
-          self.class.cache.delete(name)
+          self.class.reset_image_inspect(self.name)
         end
 
         def push!
@@ -49,21 +48,22 @@ module Dapp
           dapp.log_secondary_process(dapp.t(code: 'process.image_pull', data: { name: name })) do
             dapp.shellout!("#{dapp.host_docker} pull #{name}", verbose: true)
           end
-          cache_reset
+
+          self.class.reset_image_inspect(self.name)
         end
 
         def tagged?
-          !!id
+          not self.class.image_inspect(self.name).empty?
         end
 
         def created_at
           raise Error::Build, code: :image_not_exist, data: { name: name } unless tagged?
-          cache[:created_at]
+          self.class.image_inspect(self.name)["Created"]
         end
 
         def size
           raise Error::Build, code: :image_not_exist, data: { name: name } unless tagged?
-          cache[:size]
+          Float(self.class.image_inspect(self.name)["Size"])
         end
 
         def config_option(option)
@@ -71,37 +71,42 @@ module Dapp
           self.class.image_config_option(image_id: built_id, option: option)
         end
 
-        def cache_reset
-          self.class.cache_reset(name)
-        end
-
         class << self
-          def image_config(image_id)
-            image_configs[image_id] ||= begin
-              output = ::Dapp::Dapp.shellout!("#{::Dapp::Dapp.host_docker} inspect --format='{{json .Config}}' #{image_id}").stdout.strip
-              JSON.parse(output)
+          def image_inspect(image_id)
+            image_inspects[image_id] ||= begin
+              cmd = ::Dapp::Dapp.shellout("#{::Dapp::Dapp.host_docker} inspect --type=image #{image_id}")
+
+              if cmd.exitstatus != 0
+                if cmd.stderr.start_with? "Error: No such image:"
+                  {}
+                else
+                  ::Dapp::Dapp.shellout_cmd_should_succeed! cmd
+                end
+              else
+                Array(JSON.parse(cmd.stdout.strip)).first || {}
+              end
             end
           end
 
+          def image_config(image_id)
+            image_inspect(image_id)["Config"] || {}
+          end
+
           def image_config_option(image_id:, option:)
             image_config(image_id)[option]
           end
 
-          def image_config_delete(image_id)
-            image_configs.delete(image_id)
+          def reset_image_inspect(image_id)
+            image_inspects.delete(image_id)
           end
 
-          def image_configs
-            @image_configs ||= {}
+          def image_inspects
+            @image_inspects ||= {}
           end
         end
 
         protected
 
-        def cache
-          self.class.cache[name.to_s] || {}
-        end
-
         class << self
           def image_name_format
             "#{DockerRegistry.repo_name_format}(:(?<tag>#{tag_format}))?"
@@ -121,12 +126,7 @@ module Dapp
 
           def tag!(id:, tag:, verbose: false, quiet: false)
             ::Dapp::Dapp.shellout!("#{::Dapp::Dapp.host_docker} tag #{id} #{tag}", verbose: verbose, quiet: quiet)
-
-            if cache_entry = cache.values.find {|v| v[:id] == id}
-              cache[tag] = cache_entry
-            else
-              cache_reset
-            end
+            image_inspects[tag] = image_inspect(id)
           end
 
           def save!(image_or_images, file_path, verbose: false, quiet: false)
@@ -137,43 +137,6 @@ module Dapp
           def load!(file_path, verbose: false, quiet: false)
             ::Dapp::Dapp.shellout!("#{::Dapp::Dapp.host_docker} load -i #{file_path}", verbose: verbose, quiet: quiet)
           end
-
-          def cache
-            @cache ||= (@cache = {}).tap { cache_reset }
-          end
-
-          def cache_reset(name = '')
-            # FIXME: rework images cache, then delete time measure
-            #t = Time.now
-            cache.delete(name)
-            ::Dapp::Dapp.shellout!("#{::Dapp::Dapp.host_docker} images --format='{{.Repository}}:{{.Tag}};{{.ID}};{{.CreatedAt}};{{.Size}}' --no-trunc #{name}")
-                        .stdout
-                        .lines
-                        .each do |l|
-              name, id, created_at, size_field = l.split(';').map(&:strip)
-              name = name.reverse.chomp('docker.io/'.reverse).reverse
-              size = begin
-                match = size_field.match(/^(\S*\d)\ ?(b|kb|mb|gb|tb)$/i)
-                raise Error::Build, code: :unsupported_docker_image_size_format, data: {value: size_field} unless match and match[1] and match[2]
-
-                number = match[1].to_f
-                unit = match[2].downcase
-
-                coef = case unit
-                       when 'b'  then 0
-                       when 'kb' then 1
-                       when 'mb' then 2
-                       when 'gb' then 3
-                       when 'tb' then 4
-                       end
-
-                number * (1000**coef)
-              end
-              cache[name] = { id: id, created_at: created_at, size: size }
-              image_config_delete(id)
-            end
-            #p [:cache_reset, name, :took, Time.now - t]
-          end
         end
       end # Docker
     end # Image

data/lib/dapp/version.rb

@@ -1,4 +1,4 @@
 module Dapp
-  VERSION = '0.18.5'.freeze
-  BUILD_CACHE_VERSION = 20
+  VERSION = '0.19.0'.freeze
+  BUILD_CACHE_VERSION = 21
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dapp
 version: !ruby/object:Gem::Version
-  version: 0.18.5
+  version: 0.19.0
 platform: ruby
 authors:
 - Dmitry Stolyarov