dapp 0.32.10 → 0.33.0

data/lib/dapp/dimg/builder/shell.rb

@@ -1,29 +1,5 @@
 module Dapp
   module Dimg
-    class Builder::Shell < Builder::Base
-      [:before_install, :before_setup, :install, :setup, :build_artifact].each do |stage|
-        define_method("#{stage}_checksum") do
-          _checksum(
-            dimg.config._shell.public_send("_#{stage}_command"),
-            public_send("#{stage}_version_checksum")
-          )
-        end
-        define_method("#{stage}_version_checksum") do
-          _checksum(dimg.config._shell.public_send("_#{stage}_version"), dimg.config._shell._version)
-        end
-        define_method("#{stage}?") { !stage_empty?(stage) }
-        define_method(stage.to_s) do |image|
-          image.add_command(*stage_commands(stage)) unless stage_empty?(stage)
-        end
-      end
-
-      def stage_empty?(stage)
-        stage_commands(stage).empty? && public_send("#{stage}_version_checksum").nil?
-      end
-
-      def stage_commands(stage)
-        dimg.config._shell.public_send("_#{stage}_command")
-      end
-    end # Builder::Shell
+    class Builder::Shell < Builder::Ruby2Go; end
   end # Dimg
 end # Dapp

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

@@ -19,27 +19,22 @@ BANNER
         extend ::Dapp::CLI::Options::Ssh
 
         option :tmp_dir_prefix,
-               long: '--tmp-dir-prefix PREFIX',
-               description: 'Tmp directory prefix (/tmp by default). Used for build process service directories.'
+              long: '--tmp-dir-prefix PREFIX',
+              description: 'Tmp directory prefix (/tmp by default). Used for build process service directories.'
 
         option :lock_timeout,
-               long: '--lock-timeout TIMEOUT',
-               description: 'Redefine resource locking timeout (in seconds)',
-               proc: ->(v) { v.to_i }
+              long: '--lock-timeout TIMEOUT',
+              description: 'Redefine resource locking timeout (in seconds)',
+              proc: ->(v) { v.to_i }
 
         option :build_context_directory,
-               long: '--build-context-directory DIR_PATH',
-               default: nil
+              long: '--build-context-directory DIR_PATH',
+              default: nil
 
         option :use_system_tar,
-               long: '--use-system-tar',
-               boolean: true,
-               default: false
-
-        option :force_save_cache,
-               long: '--force-save-cache',
-               boolean: true,
-               default: false
+              long: '--use-system-tar',
+              boolean: true,
+              default: false
 
         # push options
 

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

@@ -32,11 +32,6 @@ BANNER
                long: '--use-system-tar',
                boolean: true,
                default: false
-
-        option :force_save_cache,
-               long: '--force-save-cache',
-               boolean: true,
-               default: false
       end
     end
   end

data/lib/dapp/dimg/config/directive/docker/base.rb

@@ -9,7 +9,7 @@ module Dapp
             def from(image, cache_version: nil)
               sub_directive_eval do
                 image = image.to_s
-                raise(::Dapp::Error::Config, code: :docker_from_incorrect, data: { name: image }) unless ::Dapp::Dimg::Image::Docker.image_name?(image)
+                raise(::Dapp::Error::Config, code: :docker_from_incorrect, data: { name: image }) unless ::Dapp::Dimg::Image::Stage.image_name?(image)
                 @_from = image.include?(':') ? image : [image, 'latest'].join(':')
                 @_from_cache_version = cache_version
               end

data/lib/dapp/dimg/dapp/command/build_context/export.rb

@@ -18,7 +18,7 @@ module Dapp
                 end.flatten
 
                 log_secondary_process(:images, short: true) do
-                  Image::Docker.save!(context_images_names, build_context_images_tar, verbose: true, quiet: log_quiet?) unless dry_run?
+                  Image::Stage.save!(self, context_images_names, build_context_images_tar, verbose: true, quiet: log_quiet?) unless dry_run?
                 end unless context_images_names.empty?
               end
             end

data/lib/dapp/dimg/dapp/command/build_context/import.rb

@@ -18,7 +18,7 @@ module Dapp
               if build_context_images_tar.exist?
                 log_secondary_process(:images) do
                   lock("#{name}.images") do
-                    Image::Docker.load!(build_context_images_tar, verbose: true, quiet: log_quiet?)
+                    Image::Stage.load!(self, build_context_images_tar, verbose: true, quiet: log_quiet?)
                   end unless dry_run?
                 end
               else

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

@@ -3,15 +3,13 @@ module Dapp
     module Dapp
       module Command
         module CleanupRepo
-          GIT_TAGS_LIMIT_POLICY                 = 10
-          EXPIRY_DATE_PERIOD_POLICY             = 60 * 60 * 24 * 30
-          GIT_COMMITS_LIMIT_POLICY              = 50
-          GIT_COMMITS_EXPIRY_DATE_PERIOD_POLICY = 60 * 60 * 24 * 30
+          GIT_TAGS_LIMIT_POLICY = 10
+          EXPIRY_DATE_PERIOD_POLICY = 60 * 60 * 24 * 30
 
           def cleanup_repo
             lock_repo(repo = option_repo) do
               log_step_with_indent(repo) do
-                log_step_with_indent('Searching for images being used in kubernetes clusters in one of the kube-config contexts') do
+                log_step_with_indent("Searching for images being used in kubernetes clusters in one of the kube-config contexts") do
                   deployed_docker_images.each do |deployed_img|
                     log(deployed_img)
                   end
@@ -54,13 +52,15 @@ module Dapp
 
           def cleanup_repo_by_nonexistent_git_primitive(registry, detailed_dimgs_images_by_scheme)
             %w(git_tag git_branch git_commit).each do |scheme|
-              cleanup_repo_by_nonexistent_git_base(registry, detailed_dimgs_images_by_scheme, scheme) do |detailed_dimg_image|
-                case scheme
-                  when 'git_tag'    then consistent_git_tags.include?(detailed_dimg_image[:tag])
-                  when 'git_branch' then consistent_git_remote_branches.include?(detailed_dimg_image[:tag])
-                  when 'git_commit' then git_own_repo.commit_exists?(detailed_dimg_image[:tag])
-                  else
-                    raise
+              cleanup_repo_by_nonexistent_git_base(detailed_dimgs_images_by_scheme, scheme) do |detailed_dimg_image|
+                delete_repo_image(registry, detailed_dimg_image) unless begin
+                  case scheme
+                    when 'git_tag'    then consistent_git_tags.include?(detailed_dimg_image[:tag])
+                    when 'git_branch' then consistent_git_remote_branches.include?(detailed_dimg_image[:tag])
+                    when 'git_commit' then git_own_repo.commit_exists?(detailed_dimg_image[:tag])
+                    else
+                      raise
+                  end
                 end
               end unless detailed_dimgs_images_by_scheme[scheme].empty?
             end
@@ -74,81 +74,56 @@ module Dapp
             @consistent_git_remote_branches ||= git_own_repo.remote_branches.map(&method(:consistent_uniq_slugify))
           end
 
-          def cleanup_repo_by_nonexistent_git_base(registry, repo_dimgs_images_by_scheme, dapp_tag_scheme)
-            nonexist_repo_images = repo_dimgs_images_by_scheme[dapp_tag_scheme]
-              .select { |dimg_image| dimg_image[:labels]['dapp-tag-scheme'] == dapp_tag_scheme }
-              .select { |dimg_image| !(yield dimg_image) }
-
-            log_step_with_indent(:"#{dapp_tag_scheme.split('_').join(' ')} nonexistent") do
-              nonexist_repo_images.each { |repo_image| delete_repo_image(registry, repo_image) }
-            end unless nonexist_repo_images.empty?
+          def cleanup_repo_by_nonexistent_git_base(repo_dimgs_images_by_scheme, dapp_tag_scheme)
+            return if repo_dimgs_images_by_scheme[dapp_tag_scheme].empty?
+            log_step_with_indent(:"nonexistent #{dapp_tag_scheme.split('_').join(' ')}") do
+              repo_dimgs_images_by_scheme[dapp_tag_scheme]
+                .select { |dimg_image| dimg_image[:labels]['dapp-tag-scheme'] == dapp_tag_scheme }
+                .each { |dimg_image| yield dimg_image }
+            end
           end
 
           def cleanup_repo_by_policies(registry, detailed_dimgs_images_by_scheme)
-            cleanup_repo_tags_by_policies(registry, detailed_dimgs_images_by_scheme)
-            cleanup_repo_commits_by_policies(registry, detailed_dimgs_images_by_scheme)
-          end
-
-          def cleanup_repo_tags_by_policies(registry, detailed_dimgs_images_by_scheme)
-            cleanup_repo_by_policies_base(
-              registry,
-              detailed_dimgs_images_by_scheme['git_tag'].select { |dimg| consistent_git_tags.include?(dimg[:tag]) },
-              expiry_date_policy: git_tags_expiry_date_policy,
-              limit_policy:       git_tags_limit_policy,
-              log_primitive:      'tag'
-            )
-          end
-
-          def cleanup_repo_commits_by_policies(registry, detailed_dimgs_images_by_scheme)
-            cleanup_repo_by_policies_base(
-              registry,
-              detailed_dimgs_images_by_scheme['git_commit'].select { |dimg| git_own_repo.commit_exists?(dimg[:tag]) },
-              expiry_date_policy: git_commits_expiry_date_policy,
-              limit_policy:       git_commits_limit_policy,
-              log_primitive:      'commit'
-            )
-          end
-
-          def cleanup_repo_by_policies_base(registry, detailed_dimgs_images, expiry_date_policy:, limit_policy:, log_primitive:)
-            sorted_detailed_dimgs_images = detailed_dimgs_images.sort_by { |dimg| dimg[:created_at] }.reverse
-
-            expired_dimgs_images, not_expired_dimgs_images = sorted_detailed_dimgs_images.partition do |dimg_image|
-              dimg_image[:created_at] < expiry_date_policy
-            end
+            %w(git_tag git_commit).each_with_object([]) do |scheme, dimgs_images|
+              dimgs_images.concat begin
+                detailed_dimgs_images_by_scheme[scheme].select do |dimg|
+                  if scheme == 'git_tag'
+                    consistent_git_tags.include?(dimg[:tag])
+                  elsif scheme == 'git_commit'
+                    git_own_repo.commit_exists?(dimg[:tag])
+                  end
+                end
+              end
+            end.tap do |detailed_dimgs_images|
+              sorted_detailed_dimgs_images = detailed_dimgs_images.sort_by { |dimg| dimg[:created_at] }.reverse
+              expired_dimgs_images, not_expired_dimgs_images = sorted_detailed_dimgs_images.partition do |dimg_image|
+                dimg_image[:created_at] < expiry_date_policy
+              end
 
-            log_step_with_indent(:"git #{log_primitive} date policy (before #{DateTime.strptime(expiry_date_policy.to_s, '%s')})") do
-              expired_dimgs_images.each { |dimg| delete_repo_image(registry, dimg) }
-            end unless expired_dimgs_images.empty?
+              log_step_with_indent(:"date policy (before #{DateTime.strptime(expiry_date_policy.to_s, '%s')})") do
+                expired_dimgs_images.each { |dimg| delete_repo_image(registry, dimg) }
+              end
 
-            not_expired_dimgs_images
-              .each_with_object({}) { |dimg, images_by_dimg| (images_by_dimg[dimg[:dimg]] ||= []) << dimg }
-              .each do |dimg_name, images|
-              next if images[limit_policy..-1].nil?
-              log_step_with_indent(:"git #{log_primitive} limit policy (> #{limit_policy}) (`#{dimg_name || 'nameless'}` dimg)") do
-                images[limit_policy..-1].each { |dimg| delete_repo_image(registry, dimg) }
+              {}.tap do |images_by_dimg|
+                not_expired_dimgs_images.each { |dimg| (images_by_dimg[dimg[:dimg]] ||= []) << dimg }
+                images_by_dimg.each do |dimg, images|
+                  log_step_with_indent(:"limit policy (> #{git_tag_limit_policy}) (`#{dimg || "nameless"}` dimg)") do
+                    images[git_tag_limit_policy..-1].each { |dimg| delete_repo_image(registry, dimg) }
+                  end unless images[git_tag_limit_policy..-1].nil?
+                end
               end
             end
           end
 
-          def git_tags_expiry_date_policy
-            @git_tags_expiry_date_policy ||= expiry_date_policy_value('EXPIRY_DATE_PERIOD_POLICY', default: EXPIRY_DATE_PERIOD_POLICY)
-          end
-
-          def git_tags_limit_policy
-            @git_tags_limit_policy ||= policy_value('GIT_TAGS_LIMIT_POLICY', default: GIT_TAGS_LIMIT_POLICY)
-          end
-
-          def git_commits_expiry_date_policy
-            @git_commits_expiry_date_policy ||= expiry_date_policy_value('GIT_COMMITS_EXPIRY_DATE_PERIOD_POLICY', default: GIT_COMMITS_EXPIRY_DATE_PERIOD_POLICY)
-          end
-
-          def git_commits_limit_policy
-            @git_commits_limit_policy ||= policy_value('GIT_COMMITS_LIMIT_POLICY', default: GIT_COMMITS_LIMIT_POLICY)
+          def expiry_date_policy
+            @expiry_date_policy = begin
+              expiry_date_period_policy = policy_value('EXPIRY_DATE_PERIOD_POLICY', default: EXPIRY_DATE_PERIOD_POLICY)
+              Time.now.to_i - expiry_date_period_policy
+            end
           end
 
-          def expiry_date_policy_value(env_key, default:)
-            expiry_date_period_policy = policy_value(env_key, default: default)
-            Time.now.to_i - expiry_date_period_policy
+          def git_tag_limit_policy
+            @git_tag_limit_policy ||= policy_value('GIT_TAGS_LIMIT_POLICY', default: GIT_TAGS_LIMIT_POLICY)
           end
 
           def policy_value(env_key, default:)
@@ -225,65 +200,59 @@ module Dapp
           # pod items[] spec containers[] image
           def pod_images(client)
             client.pod_list['items'].map do |item|
-              images_from_pod_spec(item)
+              item['spec']['containers'].map{ |cont| cont['image'] }
             end
           end
 
           # cronjob items[] spec jobTemplate spec template spec containers[] image
           def cronjob_images(client)
             client.cronjob_list['items'].map do |item|
-              images_from_pod_spec(item['spec']['jobTemplate']['spec']['template'])
+              item['spec']['jobTemplate']['spec']['template']['spec']['containers'].map{ |cont| cont['image'] }
             end
           end
 
           # daemonsets   items[] spec template spec containers[] image
           def daemonset_images(client)
             client.daemonset_list['items'].map do |item|
-              images_from_pod_spec(item['spec']['template'])
+              item['spec']['template']['spec']['containers'].map{ |cont| cont['image'] }
             end
           end
 
           # deployment   items[] spec template spec containers[] image
           def deployment_images(client)
             client.deployment_list['items'].map do |item|
-              images_from_pod_spec(item['spec']['template'])
+              item['spec']['template']['spec']['containers'].map{ |cont| cont['image'] }
             end
           end
 
           # job          items[] spec template spec containers[] image
           def job_images(client)
             client.job_list['items'].map do |item|
-              images_from_pod_spec(item['spec']['template'])
+              item['spec']['template']['spec']['containers'].map{ |cont| cont['image'] }
             end
           end
 
           # replicasets  items[] spec template spec containers[] image
           def replicaset_images(client)
             client.replicaset_list['items'].map do |item|
-              images_from_pod_spec(item['spec']['template'])
+              item['spec']['template']['spec']['containers'].map{ |cont| cont['image'] }
             end
           end
 
            # replicasets  items[] spec template spec containers[] image
            def statefulset_images(client)
             client.statefulset_list['items'].map do |item|
-              images_from_pod_spec(item['spec']['template'])
+              item['spec']['template']['spec']['containers'].map{ |cont| cont['image'] }
             end
           end
 
           # replicationcontroller    items[] spec template spec containers[] image
           def replicationcontroller_images(client)
             client.replicationcontroller_list['items'].map do |item|
-              images_from_pod_spec(item['spec']['template'])
+              item['spec']['template']['spec']['containers'].map{ |cont| cont['image'] }
             end
           end
 
-          def images_from_pod_spec(pod_spec)
-            containers = Array(pod_spec['spec']['containers'])
-            initContainers = Array(pod_spec['spec']['initContainers'])
-            (containers + initContainers).map { |cont| cont['image'] }
-          end
-
           def without_kube?
             !!options[:without_kube]
           end

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

@@ -18,41 +18,48 @@ module Dapp
           end
 
           def dapp_project_image_by_id(image_id)
-            dapp_project_images.find { |image| image[:id] == image_id }
-          end
-
-          def dapp_project_image_labels(image)
-            dapp_project_image_inspect(image)['Config']['Labels']
-          end
-
-          def dapp_project_image_inspect(image)
-            image[:inspect] ||= begin
-              cmd = shellout!("#{::Dapp::Dapp.host_docker} inspect --type=image #{image[:id]}")
-              Array(JSON.parse(cmd.stdout.strip)).first || {}
-            end
+            dapp_project_images.find { |image| image["Id"] == image_id }
           end
 
           def dapp_project_images
             @dapp_project_images ||= [].tap do |images|
-              images.concat prepare_docker_images(stage_cache, dimgstage: true)
-              images.concat prepare_docker_images('-f label=dapp-dimg=true', dimg: true)
+              images.concat prepare_docker_images(extra_filters: [{ reference: stage_cache }], extra_image_fields: { dimgstage: true })
+              images.concat prepare_docker_images(extra_filters: [{ label: "dapp-dimg=true" }], extra_image_fields: { dimg: true })
             end
           end
 
-          def prepare_docker_images(extra_args, **extra_fields)
-            [].tap do |images|
-              shellout!(%(#{host_docker} images --format='{{if ne "<none>" .Tag }}{{.ID}};{{.Repository}}:{{.Tag}};{{.CreatedAt}}{{ end }}' -f "dangling=false" -f "label=dapp=#{name}" --no-trunc #{extra_args}))
-                .stdout
-                .lines
-                .map(&:strip)
-                .reject(&:empty?)
-                .each do |l|
-                id, name, created_at = l.split(';')
-                images << { id: id, name: name, created_at: Time.parse(created_at).to_i, **extra_fields }
+          def prepare_docker_images(extra_filters: [], extra_image_fields: {})
+            filters = []
+            filters << { dangling: "false" }
+            filters << { label: "dapp=#{name}" }
+            filters.concat(extra_filters)
+
+            ruby2go_image_images(filters, ignore_tagless: true).map { |image| image.merge(**extra_image_fields) }
+          end
+
+          def ruby2go_image_images(filters, ignore_tagless:)
+            Image::Stage.ruby2go_command(self, command: :images, options: { filters: filters }).tap do |images|
+              if ignore_tagless
+                break images.select do |image|
+                  image["RepoTags"].reject! { |tag| tag.split(":").last == '<none>' }
+                  !image["RepoTags"].empty?
+                end
               end
             end
           end
 
+          def ruby2go_image_containers(filters)
+            Image::Stage.ruby2go_command(self, command: :containers, options: { filters: filters })
+          end
+
+          def ruby2go_image_rm(ids, force: false)
+            Image::Stage.ruby2go_command(self, command: :rm, options: { ids: ids, force: force })
+          end
+
+          def ruby2go_image_rmi(ids, force: false)
+            Image::Stage.ruby2go_command(self, command: :rmi, options: { ids: ids, force: force })
+          end
+
           def remove_project_images(project_images, force: false)
             update_project_images_cache(project_images)
             remove_images(project_images_to_delete(project_images), force: force)
@@ -63,49 +70,51 @@ module Dapp
           end
 
           def array_hash_delete_if_by_id(project_images, *images)
-            project_images.delete_if { |image| images.flatten.any? { |i| image[:id] == i[:id] } }
+            project_images.delete_if { |image| images.flatten.any? { |i| image["Id"] == i["Id"] } }
           end
 
           def project_images_to_delete(project_images)
-            project_images.map { |image| image[:dangling] ? image[:id] : image[:name] }
+            project_images.map { |i| i["RepoTags"] }.flatten.uniq
           end
 
           def dapp_containers_flush_by_label(label)
             log_proper_containers do
-              remove_containers_by_query(%(#{host_docker} ps -a -f "label=#{label}" -f "name=dapp.build." -q --no-trunc))
+              containers = ruby2go_image_containers([{ name: "dapp.build.", label: label }])
+              remove_containers(containers.map { |c| c["Id"] })
             end
           end
 
           def dapp_dangling_images_flush_by_label(label)
             log_proper_flush_dangling_images do
-              remove_images_by_query(%(#{host_docker} images -f "dangling=true" -f "label=#{label}" -q --no-trunc))
+              images = ruby2go_image_images([{ dangling: "true", label: label }], ignore_tagless: false)
+              remove_images(images.map { |i| i["Id"] })
             end
           end
 
           def dapp_tagless_images_flush
-            remove_images_by_query(%(#{host_docker} images --format='{{if eq "<none>" .Tag }}{{.ID}}{{ end }}' -f "dangling=false" -f "label=dapp" -q --no-trunc))
-          end
-
-          def remove_images_by_query(images_query)
-            with_subquery(images_query) { |ids| remove_images(ids) }
+            remove_images begin
+              ruby2go_image_images([{ dangling: "false", label: "dapp" }], ignore_tagless: false)
+                .map { |image| image["RepoTags"].select { |tag| tag.split(":").last == "<none>" } }
+                .flatten
+            end
           end
 
           def remove_images(images_ids_or_names, force: false)
-            ids_chunks(images_ids_or_names) do |chunk|
-              chunk = ignore_used_images(chunk) unless force
-              remove_base("#{host_docker} rmi%{force_option} %{ids}", chunk, force: force)
-            end
+            proc = proc { |refs| ruby2go_image_rmi(refs, force: force) }
+            images_ids_or_names = ignore_used_images(images_ids_or_names) unless force
+            remove_base(images_ids_or_names, proc: proc)
           end
 
           def ignore_used_images(images_ids_or_names)
             not_used_images = proc do |*image_id_or_name, log: true|
-              images = image_id_or_name.flatten
-              filters = images.map { |iion| "--filter=ancestor=#{iion}" }.join(' ')
-              res = shellout!(%(#{host_docker} ps -a -q #{filters})).stdout.strip
-              if res.empty?
+              images     = image_id_or_name.flatten
+              filters    = images.map { |ref| { ancestor: ref } }
+
+              containers = ruby2go_image_containers(filters).select { |c| images.include?(c["Image"]) || images.include?(c["ImageID"]) } # ancestor filter matches containers based on its image or a descendant of it
+              if containers.empty?
                 true
               else
-                log_info("Skip `#{images.join('`, `')}` (used by containers: #{res.split.join(' ')})") if log
+                log_info("Skip `#{images.join('`, `')}` (used by containers: #{ containers.map { |c| c["Id"] }.join(' ')})") if log
                 false
               end
             end
@@ -117,35 +126,16 @@ module Dapp
             end
           end
 
-          def remove_containers_by_query(containers_query)
-            with_subquery(containers_query) { |ids| remove_containers(ids) }
-          end
-
           def remove_containers(ids)
-            ids_chunks(ids) do |chunk|
-              remove_base("#{host_docker} rm%{force_option} %{ids}", chunk, force: true)
-            end
+            proc = proc { |refs| ruby2go_image_rm(refs, force: true) }
+            remove_base(ids, proc: proc)
           end
 
-          def ids_chunks(ids, &blk)
-            return if ids.empty?
-            ids.uniq.each_slice(50, &blk)
-          end
-
-          def remove_base(query_format, ids, force: false)
-            return if ids.empty?
-            force_option = force ? ' -f' : ''
-            log(ids.join("\n")) if log_verbose? || dry_run?
-            run_command(format(query_format, force_option: force_option, ids: ids.join(' ')))
-          end
-
-          def with_subquery(query)
-            return if (res = shellout!(query).stdout.strip.lines.map(&:strip)).empty?
-            yield(res)
-          end
-
-          def run_command(cmd)
-            shellout!(cmd) unless dry_run?
+          def remove_base(ids, proc:)
+            return              if ids.empty?
+            ids.uniq!
+            log(ids.join("\n")) if dry_run?
+            proc.call(ids)      unless dry_run?
           end
 
           def dimg_import_export_base(should_be_built: true)
@@ -158,20 +148,16 @@ module Dapp
             end
           end
 
-          def container_name_prefix
-            name
-          end
-
           def validate_repo_name!(repo)
             raise ::Dapp::Error::Command, code: :repo_name_incorrect, data: { name: repo } unless ::Dapp::Dimg::DockerRegistry.repo_name?(repo)
           end
 
           def validate_image_name!(image)
-            raise ::Dapp::Error::Command, code: :image_name_incorrect, data: { name: image } unless ::Dapp::Dimg::Image::Docker.image_name?(image)
+            raise ::Dapp::Error::Command, code: :image_name_incorrect, data: { name: image } unless ::Dapp::Dimg::Image::Stage.image_name?(image)
           end
 
           def validate_tag_name!(tag)
-            raise ::Dapp::Error::Command, code: :tag_name_incorrect, data: { name: tag } unless ::Dapp::Dimg::Image::Docker.tag?(tag)
+            raise ::Dapp::Error::Command, code: :tag_name_incorrect, data: { name: tag } unless ::Dapp::Dimg::Image::Stage.tag?(tag)
           end
 
           def proper_cache_version?