dapp 0.8.0 → 0.9.0

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

@@ -1,138 +0,0 @@
-module Dapp
-  # Project
-  class Project
-    # Command
-    module Command
-      module Stages
-        # CleanupLocal
-        module CleanupLocal
-          def stages_cleanup_local(repo)
-            lock_repo(repo, readonly: true) do
-              raise Error::Project, code: :stages_cleanup_required_option unless stages_cleanup_option?
-
-              project_containers_flush
-
-              proper_cache                 if proper_cache_version?
-              stages_cleanup_by_repo(repo) if proper_repo_cache?
-              proper_git_commit            if proper_git_commit?
-            end
-          end
-
-          protected
-
-          def proper_cache
-            log_proper_cache do
-              lock("#{name}.images") do
-                log_step_with_indent(name) do
-                  remove_images(project_images_names.select { |image_name| !actual_cache_images.include?(image_name) })
-                end
-              end
-            end
-          end
-
-          def stages_cleanup_by_repo(repo)
-            registry = registry(repo)
-            repo_dimgs = repo_dimgs_images(registry)
-
-            lock("#{name}.images") do
-              log_step_with_indent(name) do
-                project_dangling_images_flush
-                dimgs, stages = project_images_hash.partition { |_, image_id| repo_dimgs.values.include?(image_id) }
-                dimgs = dimgs.to_h
-                stages = stages.to_h
-                dimgs.each { |_, aiid| except_image_with_parents(aiid, stages) }
-                remove_images(stages.keys)
-              end
-            end
-          end
-
-          def repo_dimgs_images(registry)
-            repo_dimgs_and_cache(registry).first
-          end
-
-          def actual_cache_images
-            shellout!([
-              'docker images',
-              '--format="{{.Repository}}:{{.Tag}}"',
-              %(-f "label=dapp-cache-version=#{Dapp::BUILD_CACHE_VERSION}"),
-              stage_cache
-            ].join(' ')).stdout.lines.map(&:strip)
-          end
-
-          def project_images_hash
-            shellout!(%(docker images --format "{{.Repository}}:{{.Tag}};{{.ID}}" --no-trunc #{stage_cache})).stdout.lines.map do |line|
-              line.strip.split(';')
-            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) }
-              iid = image_id
-              loop do
-                stages.delete_if { |_, siid| siid == iid }
-                break if (iid = image_parent(iid)).empty?
-              end
-            else
-              stages.delete_if { |_, siid| siid == image_id }
-            end
-          end
-
-          def image_exist?(image_id)
-            shellout!(%(docker inspect #{image_id}))
-            true
-          rescue Error::Shellout
-            false
-          end
-
-          def image_dapp_artifacts_label(image_id)
-            select_dapp_artifacts_ids(Image::Docker.image_config_option(image_id: image_id, option: 'labels'))
-          end
-
-          def image_parent(image_id)
-            shellout!(%(docker inspect -f {{.Parent}} #{image_id})).stdout.strip
-          end
-
-          def proper_git_commit
-            log_proper_git_commit do
-              unproper_images_names = []
-              project_images_detailed.each do |_, attrs|
-                attrs['Config']['Labels'].each do |repo_name, commit|
-                  next if (repo = project_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 project_images_detailed
-            @project_images_detailed ||= {}.tap do |images|
-              project_images_names.each do |image_name|
-                shellout!(%(docker inspect --format='{{json .}}' #{image_name})).stdout.strip.tap do |output|
-                  images[image_name] = output == 'null' ? {} : JSON.parse(output)
-                end
-              end
-            end
-          end
-
-          def image_hierarchy_by_id(image_id)
-            hierarchy = []
-            iids = [image_id]
-
-            loop do
-              hierarchy.concat(project_images_detailed.map { |name, attrs| name if iids.include?(attrs['Id']) }.compact)
-              break if begin
-                iids.map! do |iid|
-                  project_images_detailed.map { |_, attrs| attrs['Id'] if attrs['Parent'] == iid }.compact
-                end.flatten!.empty?
-              end
-            end
-
-            hierarchy
-          end
-        end
-      end
-    end
-  end # Project
-end # Dapp

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

@@ -1,125 +0,0 @@
-module Dapp
-  # Project
-  class Project
-    # Command
-    module Command
-      module Stages
-        # CleanupRepo
-        module CleanupRepo
-          def stages_cleanup_repo(repo)
-            lock_repo(repo) do
-              raise Error::Project, code: :stages_cleanup_required_option unless stages_cleanup_option?
-
-              registry = registry(repo)
-              repo_dimgs, repo_stages = repo_dimgs_and_cache(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?
-              repo_stages_cleanup(registry, repo_dimgs, repo_stages) if proper_repo_cache?
-              proper_repo_git_commit(registry)                       if proper_git_commit?
-            end
-          end
-
-          protected
-
-          def proper_repo_cache(registry, repo_stages)
-            log_proper_cache do
-              wrong_cache_images = repo_stages.select do |image_tag, _|
-                repo_image_dapp_cache_version_label(registry, image_tag) != Dapp::BUILD_CACHE_VERSION.to_s
-              end
-              wrong_cache_images.each { |image_tag, _| delete_repo_image(registry, image_tag) }
-              repo_stages.delete_if { |image_tag, _| wrong_cache_images.keys.include?(image_tag) }
-            end
-          end
-
-          def repo_stages_cleanup(registry, repo_dimgs, repo_stages)
-            log_step_with_indent(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
-          end
-
-          def clear_repo_stages(registry, repo_stages, image_tag, image_id)
-            repo_image_dapp_artifacts_labels(registry, image_tag).each do |iid|
-              itag = find_image_tag_by_id(repo_stages, iid)
-              clear_repo_stages(registry, repo_stages, itag, iid) unless itag.nil?
-            end
-
-            itag = image_tag
-            iid = image_id
-            loop do
-              repo_stages.delete_if { |_, siid| siid == iid }
-              break if itag.nil? || (iid = registry.image_parent_id(itag)).empty?
-              itag = find_image_tag_by_id(repo_stages, iid)
-            end
-          end
-
-          def repo_image_dapp_artifacts_labels(registry, image_tag)
-            select_dapp_artifacts_ids(registry.image_labels(image_tag))
-          end
-
-          def repo_image_dapp_cache_version_label(registry, image_tag)
-            registry.image_labels(image_tag)['dapp-cache-version']
-          end
-
-          def find_image_tag_by_id(images, image_id)
-            images.each { |tag, id| return tag if id == image_id }
-            nil
-          end
-
-          def proper_repo_git_commit(registry)
-            log_proper_git_commit do
-              unproper_images = []
-              repo_project_dappstage_images_detailed(registry).each do |_, attrs|
-                attrs[:labels].each do |repo_name, commit|
-                  next if (repo = project_git_repositories[repo_name]).nil?
-                  unproper_images.concat(repo_image_tags_hierarchy(registry, attrs[:id])) unless repo.commit_exists?(commit)
-                end
-              end
-              remove_repo_images(registry, unproper_images.uniq)
-            end
-          end
-
-          def repo_project_dappstage_images_detailed(registry)
-            @repo_project_images_detailed ||= begin
-              registry.tags.map do |tag|
-                next unless tag.start_with?('dimgstage')
-
-                image_history = registry.image_history(tag)
-                attrs = {
-                  id: registry.image_id(tag),
-                  parent: image_history['container_config']['Image'],
-                  labels: image_history['config']['Labels']
-                }
-                [tag, attrs]
-              end.compact
-            end
-          end
-
-          def repo_image_tags_hierarchy(registry, registry_image_id)
-            hierarchy = []
-            iids = [registry_image_id]
-
-            loop do
-              hierarchy.concat(iids)
-              break if begin
-                iids.map! do |iid|
-                  repo_project_dappstage_images_detailed(registry).map { |_, attrs| attrs[:id] if attrs[:parent] == iid }.compact
-                end.flatten!.empty?
-              end
-            end
-
-            repo_project_dappstage_images_detailed(registry).map { |tag, attrs| tag if hierarchy.include? attrs[:id] }.compact
-          end
-
-          def remove_repo_images(registry, tags)
-            tags.each do |tag|
-              log(tag) if dry_run? || log_verbose?
-              registry.image_delete(tag) unless dry_run?
-            end
-          end
-        end
-      end
-    end
-  end # Project
-end # Dapp

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

@@ -1,86 +0,0 @@
-module Dapp
-  # Project
-  class Project
-    # Command
-    module Command
-      module Stages
-        # Common
-        module Common
-          protected
-
-          def registry(repo)
-            validate_repo_name(repo)
-            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
-            end
-            dimgs, stages = registry.tags.partition { |tag| !tag.start_with?('dimgstage') }
-            [format.call(dimgs), format.call(stages)]
-          end
-
-          def registry_tags(registry)
-            registry.tags
-          rescue Exception::Registry => e
-            raise unless e.net_status[:code] == :no_such_dimg
-            log_warning(desc: { code: :dimg_not_found_in_registry })
-            []
-          end
-
-          def delete_repo_image(registry, image_tag)
-            if dry_run?
-              log(image_tag)
-            else
-              registry.image_delete(image_tag)
-            end
-          end
-
-          def select_dapp_artifacts_ids(hash)
-            hash.select { |k, _v| k.start_with?('dapp-artifact') }.values
-          end
-
-          def project_git_repositories
-            @project_git_repositories ||= begin
-              {}.tap do |repositories|
-                dimgs = build_configs.map { |config| Dimg.new(config: config, project: self, ignore_git_fetch: true) }
-                dimgs.each do |dimg|
-                  [dimg, dimg.artifacts].flatten
-                    .map(&:git_artifacts).flatten
-                    .map { |ga_artifact| repositories[ga_artifact.full_name] = ga_artifact.repo }
-                end
-              end
-            end
-          end
-
-          def proper_repo_cache?
-            !!cli_options[:proper_repo_cache]
-          end
-
-          def proper_git_commit?
-            !!cli_options[:proper_git_commit]
-          end
-
-          def stages_cleanup_option?
-            proper_git_commit? || proper_cache_version? || proper_repo_cache?
-          end
-
-          def log_proper_git_commit(&blk)
-            log_step_with_indent(:'proper git commit', &blk)
-          end
-
-          def lock_repo(repo, *args, &blk)
-            lock("repo.#{hashsum repo}", *args, &blk)
-          end
-        end
-      end
-    end
-  end # Project
-end # Dapp

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

@@ -1,22 +0,0 @@
-module Dapp
-  # Project
-  class Project
-    # Command
-    module Command
-      module Stages
-        # FlushLocal
-        module FlushLocal
-          def stages_flush_local
-            lock("#{name}.images") do
-              log_step_with_indent(name) do
-                project_containers_flush
-                project_dangling_images_flush
-                remove_images(project_images_names)
-              end
-            end
-          end
-        end
-      end
-    end
-  end # Project
-end # Dapp

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

@@ -1,22 +0,0 @@
-module Dapp
-  # Project
-  class Project
-    # Command
-    module Command
-      module Stages
-        # FlushRepo
-        module FlushRepo
-          def stages_flush_repo(repo)
-            lock_repo(repo) do
-              log_step_with_indent(repo) do
-                registry = registry(repo)
-                repo_dimgs, repo_stages = repo_dimgs_and_cache(registry)
-                repo_dimgs.merge(repo_stages).keys.each { |image_tag| delete_repo_image(registry, image_tag) }
-              end
-            end
-          end
-        end
-      end
-    end
-  end # Project
-end # Dapp

data/lib/dapp/project/command/stages/pull.rb

@@ -1,27 +0,0 @@
-module Dapp
-  # Project
-  class Project
-    # Command
-    module Command
-      module Stages
-        # Pull
-        module Pull
-          def stages_pull(repo)
-            validate_repo_name(repo)
-            build_configs.each do |config|
-              log_dimg_name_with_indent(config) do
-                Dimg.new(config: config, project: self, ignore_git_fetch: true).tap do |dimg|
-                  dimg.import_stages!(repo, format: '%{repo}:dimgstage-%{signature}')
-                end
-              end
-            end
-          end
-
-          def pull_all_stages?
-            !!cli_options[:pull_all_stages]
-          end
-        end
-      end
-    end
-  end # Project
-end # Dapp

data/lib/dapp/project/command/stages/push.rb

@@ -1,23 +0,0 @@
-module Dapp
-  # Project
-  class Project
-    # Command
-    module Command
-      module Stages
-        # Push
-        module Push
-          def stages_push(repo)
-            validate_repo_name(repo)
-            build_configs.each do |config|
-              log_dimg_name_with_indent(config) do
-                Dimg.new(config: config, project: self, ignore_git_fetch: true, should_be_built: true).tap do |dimg|
-                  dimg.export_stages!(repo, format: '%{repo}:dimgstage-%{signature}')
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end # Project
-end # Dapp