dapp 0.10.2 → 0.36.24

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

@@ -1,94 +1,204 @@
 module Dapp
   module Dimg
-    class Dapp
+    module Dapp
       module Command
         module Common
+          def dimgstage_push_tag_format
+            'dimgstage-%{signature}'
+          end
+
           protected
 
-          def dapp_images_names
-            shellout!(%(docker images --format="{{.Repository}}:{{.Tag}}" #{stage_cache})).stdout.lines.map(&:strip)
+          def dapp_project_dimgstages
+            dapp_project_images.select { |image| image[:dimgstage] }
+          end
+
+          def dapp_project_dimgs
+            dapp_project_images.select { |image| image[:dimg] }
+          end
+
+          def dapp_project_image_by_id(image_id)
+            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(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_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 dapp_images_ids
-            shellout!(%(docker images #{stage_cache} -q --no-trunc)).stdout.lines.map(&:strip)
+          def remove_project_images(project_images, force: false)
+            update_project_images_cache(project_images)
+            remove_images(project_images_to_delete(project_images), force: force)
           end
 
-          def dapp_containers_flush
-            remove_containers_by_query(%(docker ps -a -f "label=dapp" -f "name=#{container_name_prefix}" -q), force: true)
+          def update_project_images_cache(project_images)
+            array_hash_delete_if_by_id(dapp_project_images, project_images)
           end
 
-          def dapp_dangling_images_flush
-            remove_images_by_query(%(docker images -f "dangling=true" -f "label=dapp=#{stage_dapp_label}" -q), force: true)
+          def array_hash_delete_if_by_id(project_images, *images)
+            project_images.delete_if { |image| images.flatten.any? { |i| image["Id"] == i["Id"] } }
           end
 
-          def remove_images_by_query(images_query, force: false)
-            with_subquery(images_query) { |ids| remove_images(ids, force: force) }
+          def project_images_to_delete(project_images)
+            project_images.map { |i| i["RepoTags"] }.flatten.uniq
           end
 
-          def remove_images(ids, force: false)
-            remove_base('docker rmi%{force_option} %{ids}', ids.uniq, force: force)
+          def dapp_containers_flush_by_label(label)
+            log_proper_containers do
+              containers = ruby2go_image_containers([{ name: "dapp.build.", label: label }])
+              remove_containers(containers.map { |c| c["Id"] })
+            end
           end
 
-          def remove_containers_by_query(containers_query, force: false)
-            with_subquery(containers_query) { |ids| remove_containers(ids, force: force) }
+          def dapp_dangling_images_flush_by_label(label)
+            log_proper_flush_dangling_images do
+              images = ruby2go_image_images([{ dangling: "true", label: label }], ignore_tagless: false)
+              remove_images(images.map { |i| i["Id"] })
+            end
           end
 
-          def remove_containers(ids, force: false)
-            remove_base('docker rm%{force_option} %{ids}', ids.uniq, force: force)
+          def dapp_tagless_images_flush
+            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_base(query_format, ids, force: false)
-            return if ids.empty?
-            force_option = force ? ' -f' : ''
-            ids.each_slice(50) { |chunk| run_command(format(query_format, force_option: force_option, ids: chunk.join(' '))) }
+          def remove_images(images_ids_or_names, force: false)
+            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 with_subquery(query)
-            return if (res = shellout!(query).stdout.strip.lines.map(&:strip)).empty?
-            yield(res)
+          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 { |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: #{ containers.map { |c| c["Id"] }.join(' ')})") if log
+                false
+              end
+            end
+
+            if not_used_images.call(images_ids_or_names, log: false)
+              images_ids_or_names
+            else
+              images_ids_or_names.select(&not_used_images)
+            end
           end
 
-          def image_labels(image_id)
-            Image::Stage.image_config_option(image_id: image_id, option: 'labels')
+          def remove_containers(ids)
+            proc = proc { |refs| ruby2go_image_rm(refs, force: true) }
+            remove_base(ids, proc: proc)
           end
 
-          def run_command(cmd)
-            log(cmd) if log_verbose? || dry_run?
-            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)
+            repo = option_repo
+            validate_repo_name!(repo)
+            build_configs.each do |config|
+              log_dimg_name_with_indent(config) do
+                yield dimg(config: config, should_be_built: should_be_built)
+              end
+            end
           end
 
-          def container_name_prefix
-            name
+          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_repo_name(repo)
-            raise(Error::Command, code: :repo_name_incorrect, data: { name: repo }) unless ::Dapp::Dimg::DockerRegistry.repo_name?(repo)
+          def validate_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::Stage.tag?(tag)
           end
 
           def proper_cache_version?
-            !!cli_options[:proper_cache_version]
+            !!options[:proper_cache_version]
           end
 
           def log_proper_cache(&blk)
             log_step_with_indent(:'proper cache', &blk)
           end
 
-          def one_dimg!
-            return if build_configs.one?
-            raise Error::Command, code: :command_unexpected_dimgs_number, data: { dimgs_names: build_configs.map(&:_name).join(' ') }
+          def log_proper_repo_cache(&blk)
+            log_step_with_indent(:'proper repo cache', &blk)
+          end
+
+          def log_proper_containers(&blk)
+            log_step_with_indent(:'proper containers', &blk)
+          end
+
+          def log_proper_flush_dangling_images(&blk)
+            log_step_with_indent(:'proper dangling', &blk)
           end
 
           def push_format(dimg_name)
             if dimg_name.nil?
               spush_format
             else
-              '%{repo}:%{dimg_name}-%{tag}'
+              '%{repo}/%{dimg_name}:%{tag}'
             end
           end
 
           def spush_format
             '%{repo}:%{tag}'
           end
+
+          def dimgstage_push_format
+            "%{repo}:#{dimgstage_push_tag_format}"
+          end
+
+          def with_stages?
+            !!options[:with_stages]
+          end
         end
       end
     end

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

@@ -0,0 +1,25 @@
+module Dapp
+  module Dimg
+    module Dapp
+      module Command
+        module FlushLocal
+          def flush_local
+            ruby2go_cleanup_command(:flush, ruby2go_cleanup_flush_local_options_dump)
+          end
+
+          def ruby2go_cleanup_flush_local_options_dump
+            ruby2go_cleanup_common_project_options.merge(
+              mode: {
+                with_dimgs: true,
+                with_stages: with_stages?,
+                only_repo: false,
+              },
+            ).tap do |data|
+              break JSON.dump(data)
+            end
+          end
+        end
+      end
+    end
+  end # Dimg
+end # Dapp

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

@@ -0,0 +1,25 @@
+module Dapp
+  module Dimg
+    module Dapp
+      module Command
+        module FlushRepo
+          def flush_repo
+            ruby2go_cleanup_command(:flush, ruby2go_cleanup_flush_repo_options_dump)
+          end
+
+          def ruby2go_cleanup_flush_repo_options_dump
+            ruby2go_cleanup_common_repo_options.merge(
+              mode: {
+                with_dimgs: true,
+                with_stages: with_stages?,
+                only_repo: true,
+              }
+            ).tap do |json|
+              break JSON.dump(json)
+            end
+          end
+        end
+      end
+    end
+  end # Dimg
+end # Dapp

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

@@ -1,6 +1,6 @@
 module Dapp
   module Dimg
-    class Dapp
+    module Dapp
       module Command
         module List
           def list

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

@@ -1,73 +1,26 @@
 module Dapp
   module Dimg
-    class Dapp
+    module Dapp
       module Command
         module Mrproper
-          # 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
-
-              if proper_all?
-                flush_by_label('dapp')
-              elsif proper_dev_mode_cache?
-                flush_by_label('dapp-dev-mode')
-              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
-              end
-            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 proper_all?
-            !!cli_options[:proper_all]
-          end
-
-          def proper_dev_mode_cache?
-            !!cli_options[:proper_dev_mode_cache]
-          end
-
-          def dapp_containers_flush_by_label(label)
-            remove_containers_by_query(%(docker ps -a -f "label=#{label}" -q), force: true)
-          end
-
-          def dapp_dangling_images_flush_by_label(label)
-            remove_images_by_query(%(docker images -f "dangling=true" -f "label=#{label}" -q), force: true)
-          end
-
-          def dapp_images_flush_by_label(label)
-            dapp_dangling_images_flush_by_label(label)
-            remove_images(dapp_images_by_label(label), force: true)
-          end
-
-          def dapp_images_by_label(label)
-            @dapp_images ||= begin
-              shellout!(%(docker images -f "dangling=false" --format="{{.Repository}}:{{.Tag}}" -f "label=#{label}"))
-                .stdout
-                .lines
-                .map(&:strip)
+            ruby2go_cleanup_command(:reset, ruby2go_cleanup_reset_options_dump)
+          end
+
+          def ruby2go_cleanup_reset_options_dump
+            ruby2go_cleanup_cache_version_options.merge(
+              mode: {
+                all: !!options[:proper_all],
+                dev_mode_cache: !!options[:proper_dev_mode_cache],
+                cache_version: proper_cache_version?
+              },
+              common_options: {
+                dry_run: dry_run?
+              },
+            ).tap do |json|
+              break JSON.dump(json)
             end
           end
-
-          def proper_cache_all_images
-            shellout!([
-              'docker images',
-              '--format="{{.Repository}}:{{.Tag}}"',
-              %(-f "label=dapp-cache-version=#{::Dapp::BUILD_CACHE_VERSION}" -f "dangling=false")
-            ].join(' ')).stdout.lines.map(&:strip)
-          end
         end
       end
     end

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

@@ -1,24 +1,19 @@
 module Dapp
   module Dimg
-    class Dapp
+    module Dapp
       module Command
         module Push
-          def push(repo)
-            validate_repo_name(repo)
-            log_step_with_indent(:stages) { stages_push(repo) } if with_stages?
-            build_configs.each do |config|
-              log_dimg_name_with_indent(config) do
-                Dimg.new(config: config, dapp: self, ignore_git_fetch: true, should_be_built: true).tap do |dimg|
-                  dimg.export!(repo, format: push_format(config._name))
-                end
-              end
+          def push
+            #require 'ruby-prof'
+            #RubyProf.start
+            log_step_with_indent(:stages) { stages_push } if with_stages?
+            dimg_import_export_base do |dimg|
+              dimg.export!(option_repo, format: push_format(dimg.name))
             end
-          end
-
-          protected
-
-          def with_stages?
-            !!cli_options[:with_stages]
+            # FIXME: rework images cache, then profile
+            #result = RubyProf.stop
+            #printer = RubyProf::MultiPrinter.new(result)
+            #printer.print(path: '/tmp/testdapp.push.profile', profile: 'profile')
           end
         end
       end

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

@@ -0,0 +1,48 @@
+module Dapp
+  module Dimg
+    module Dapp
+      module Command
+        module Ruby2GoCleanup
+          def ruby2go_cleanup_command(command, command_options, **options)
+            options = {
+              command: command,
+              command_options: command_options,
+              options: { host_docker_config_dir: self.class.host_docker_config_dir }.merge(options)
+            }
+
+            ruby2go_cleanup(options).tap do |res|
+              raise Error::Build, code: :ruby2go_cleanup_command_failed_unexpected_error, data: { command: command, message: res["error"] } unless res["error"].nil?
+            end
+          end
+
+          def ruby2go_cleanup_common_project_options
+            {
+              common_project_options: {
+                project_name: name,
+                common_options: {
+                  dry_run: dry_run?,
+                }
+              },
+            }
+          end
+
+          def ruby2go_cleanup_cache_version_options
+            {
+              cache_version: ::Dapp::BUILD_CACHE_VERSION.to_s
+            }
+          end
+
+          def ruby2go_cleanup_common_repo_options
+            {
+              common_repo_options: {
+                repository: option_repo,
+                dimgs_names: nameless_dimg? ? [] : dimgs_names,
+                dry_run: dry_run?
+              }
+            }
+          end
+        end
+      end
+    end
+  end # Dimg
+end # Dapp

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

@@ -1,12 +1,12 @@
 module Dapp
   module Dimg
-    class Dapp
+    module Dapp
       module Command
         module Run
-          def run(docker_options, command)
+          def run(stage_name, docker_options, command)
             one_dimg!
-            setup_ssh_agent
-            Dimg.new(config: build_configs.first, dapp: self, ignore_git_fetch: true, should_be_built: true).run(docker_options, command)
+            dimg(config: build_configs.first, should_be_built: stage_name.nil?, ignore_signature_auto_calculation: true)
+              .run_stage(stage_name, docker_options, command)
           end
         end
       end

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

@@ -1,13 +1,12 @@
 module Dapp
   module Dimg
-    class Dapp
+    module Dapp
       module Command
         module Spush
-          def spush(repo)
-            validate_repo_name(repo)
+          def spush
             one_dimg!
-            Dimg.new(config: build_configs.first, dapp: self, ignore_git_fetch: true, should_be_built: true).tap do |dimg|
-              dimg.export!(repo, format: spush_format)
+            dimg_import_export_base do |dimg|
+              dimg.export!(option_repo, format: spush_format)
             end
           end
         end

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

@@ -1,11 +1,11 @@
 module Dapp
   module Dimg
-    class Dapp
+    module Dapp
       module Command
         module StageImage
           def stage_image
             one_dimg!
-            puts Dimg.new(config: build_configs.first, dapp: self, ignore_git_fetch: true).stage_image_name(cli_options[:stage])
+            puts dimg(config: build_configs.first).stage_image_name(options[:stage])
           end
         end
       end