dapp 0.20.0 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25371f86eea9f7d1896fc258be654241cf1021c05bfdc472da2cd676e2bdda56
-  data.tar.gz: d2c8a9e2f4e116ab34ae80c8dae3cca09d31715cc0d80da2c71d06c323f04818
+  metadata.gz: 03083f145a1b261c09f5ac85cb210498603ae8255b9d1caf8f4a20f1c44781a5
+  data.tar.gz: 042aaa870856b1141411106909baa1d6e7e880ca43d9b87b037c09f5dc37f4ac
 SHA512:
-  metadata.gz: f89fc98080749f41fdf250897010079dd0aaa38c8ffabd1dbfc1874d5c30a40ff303521b2af0c3bc61781cafd93e97acf28562a0bd0cbccdd6c14da4a085d34e
-  data.tar.gz: e8c81970d2f75f1339aab19900874725f3147be4d82ad6febbaafa2863414065d64d65bdc79839bb62005e422d3f1d1b84ae4325d9f2aa3208e4975a74c83a25
+  metadata.gz: a337d11f46ccda094b8295a245e1416a1e0027fe23b1738181c77d1619eb79172c81d7c1a1040050d52c93227b9f6d4f9d70d866589b0edc5fc02c9edd1ed359
+  data.tar.gz: 59f31c8087e4c50b22e8135bbe943887322bd4ab021f51029d008d30a236e8ecbffa896c451c94c6989276599201e063e67c6c583860d760b5291a36749a4f8e

data/config/en/net_status.yml

@@ -6,8 +6,6 @@ en:
     dimg:
       dimg_not_built: "Dimg hasn't been built yet!"
       dimg_not_run: "Dimg run failed!"
-      git_branch_without_name: "Dimg has specific revision that isn't associated with a branch name!"
-      ci_environment_required: 'CI environment required (Travis or GitLab CI)!'
     kube:
       deploy_timeout: "Deploy timeout!"
     dappfile:
@@ -44,6 +42,7 @@ en:
       user_containers_detected: "User containers are using these images:\n%{ids}"
       incorrect_yaml_structure: "Incorrect YAML structure in `%{path}`!"
       editor_not_found: "Editor not found!"
+      expected_only_one_tag: 'Expected only one tag (`%{tags}`)!'
     dapp:
       no_such_dimg: "No such dimg: `%{dimgs_patterns}`!"
       no_such_app: "No such app: `%{apps_patterns}`!"
@@ -57,6 +56,8 @@ en:
       yaml_incorrect: "`%{message}`"
       incorrect_dapp_config_option: ".dapp_config includes option `%{option}` with incorrect value `%{value}`: expected one of the following types [%{expected}]"
       incorrect_dapp_config_option_color: ".dapp_config includes option `color` with incorrect value `%{value}`: expected one of the following values [%{expected}]"
+      ci_environment_required: 'CI environment required (Travis or GitLab CI)!'
+      git_branch_without_name: "Dimg has specific revision that isn't associated with a branch name!"
     config:
       dimg_name_required: 'Dimg name required!'
       dimg_name_incorrect: "Dimg has incorrect name `%{value}`: doesn't match regex `%{pattern}`!"
@@ -108,6 +109,7 @@ en:
       no_such_dimg: 'Registry `%{registry}`: no such dimg in registry!'
       authenticate_type_not_supported: 'Registry `%{registry}`: authenticate type is not supported!'
       page_not_found: "Registry `%{registry}`: page `%{url}` not found!"
+      method_not_allowed: "Registry `%{registry}`: method `%{method}` not allowed (`%{url}`)!"
       user_not_authorized: 'Registry `%{registry}`: user not authorized!'
     rugged:
       git_repository_reference_error: "Git repo `%{name}`: %{message}!"

data/lib/dapp.rb

@@ -53,6 +53,7 @@ require 'dapp/dapp/git_artifact'
 require 'dapp/dapp/dappfile'
 require 'dapp/dapp/chef'
 require 'dapp/dapp/dapp_config'
+require 'dapp/dapp/option_tags'
 require 'dapp/dapp/logging/base'
 require 'dapp/dapp/logging/process'
 require 'dapp/dapp/logging/paint'
@@ -258,6 +259,7 @@ require 'dapp/dimg/docker_registry'
 require 'dapp/dimg/docker_registry/base/request'
 require 'dapp/dimg/docker_registry/base/authorization'
 require 'dapp/dimg/docker_registry/base'
+require 'dapp/dimg/docker_registry/dimg'
 require 'dapp/dimg/docker_registry/default'
 require 'dapp/dimg/error/base'
 require 'dapp/dimg/error/dimg'
@@ -285,7 +287,6 @@ require 'dapp/dimg/image/stage'
 require 'dapp/dimg/image/scratch'
 require 'dapp/dimg/dimg/git_artifact'
 require 'dapp/dimg/dimg/path'
-require 'dapp/dimg/dimg/tags'
 require 'dapp/dimg/dimg/stages'
 require 'dapp/dimg/dimg'
 require 'dapp/dimg/artifact'

data/lib/dapp/dapp.rb

@@ -5,6 +5,7 @@ module Dapp
     include Dappfile
     include Chef
     include DappConfig
+    include OptionTags
 
     include Logging::Base
     include Logging::Process

data/lib/dapp/dapp/git_artifact.rb

@@ -6,6 +6,10 @@ module Dapp
           yield exclude_paths if block_given?
         end
       end
+
+      def dimgstage_ga_label(paramshash)
+        "dapp-git-#{paramshash}-commit"
+      end
     end # GitArtifact
   end # Dapp
 end # Dapp

data/lib/dapp/dapp/option_tags.rb

@@ -0,0 +1,63 @@
+module Dapp
+  class Dapp
+    module OptionTags
+      def git_local_repo
+        @git_repo ||= ::Dapp::Dimg::GitRepo::Own.new(self)
+      end
+
+      def option_tags
+        @tags ||= begin
+          tags = simple_tags + branch_tags + commit_tags + build_tags + ci_tags
+          tags << :latest if tags.empty?
+          tags
+        end
+      end
+
+      def simple_tags
+        options[:tag]
+      end
+
+      def branch_tags
+        return [] unless options[:tag_branch]
+        raise Error::Dapp, code: :git_branch_without_name if (branch = git_local_repo.branch) == 'HEAD'
+        [branch]
+      end
+
+      def commit_tags
+        return [] unless options[:tag_commit]
+        commit = git_local_repo.latest_commit
+        [commit]
+      end
+
+      def build_tags
+        return [] unless options[:tag_build_id]
+
+        if ENV['GITLAB_CI']
+          build_id = ENV['CI_BUILD_ID']
+        elsif ENV['TRAVIS']
+          build_id = ENV['TRAVIS_BUILD_NUMBER']
+        else
+          raise Error::Dapp, code: :ci_environment_required
+        end
+
+        [build_id]
+      end
+
+      def ci_tags
+        return [] unless options[:tag_ci]
+
+        if ENV['GITLAB_CI']
+          branch = ENV['CI_BUILD_REF_NAME']
+          tag = ENV['CI_BUILD_TAG']
+        elsif ENV['TRAVIS']
+          branch = ENV['TRAVIS_BRANCH']
+          tag = ENV['TRAVIS_TAG']
+        else
+          raise Error::Dapp, code: :ci_environment_required
+        end
+
+        [branch, tag].compact
+      end
+    end # Tags
+  end # Dapp
+end # Dapp

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

@@ -191,7 +191,7 @@ module Dapp
           def layer_commit(git_artifact)
             commits[git_artifact] ||= begin
               if image.tagged?
-                image.labels["dapp-git-#{git_artifact.paramshash}-commit"]
+                image.labels[dimg.dapp.dimgstage_ga_label(git_artifact.paramshash)]
               else
                 git_artifact.latest_commit
               end

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

@@ -10,7 +10,7 @@ module Dapp
               image.add_volume "#{dimg.tmp_path('patches')}:#{dimg.container_tmp_path('patches')}:ro"
 
               dimg.git_artifacts.each do |git_artifact|
-                image.add_service_change_label("dapp-git-#{git_artifact.paramshash}-commit".to_sym => git_artifact.latest_commit)
+                image.add_service_change_label(dimg.dapp.dimgstage_ga_label(git_artifact.paramshash).to_sym => git_artifact.latest_commit)
                 image.add_command git_artifact.send(apply_command_method, self)
               end
             end

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

@@ -7,10 +7,10 @@ module Dapp::Dimg::CLI
         banner <<BANNER.freeze
 Available subcommands: (for details, dapp dimg stages SUB-COMMAND --help)
 
-  dapp dimg stages cleanup local [options] [DIMG ...] [REPO]
-  dapp dimg stages cleanup repo [options] [DIMG ...] REPO
-  dapp dimg stages flush local [options] [DIMG ...]
-  dapp dimg stages flush repo [options] [DIMG ...] REPO
+  dapp dimg stages cleanup local [options] [REPO]
+  dapp dimg stages cleanup repo [options] REPO
+  dapp dimg stages flush local [options]
+  dapp dimg stages flush repo [options] REPO
   dapp dimg stages push [options] [DIMG ...] REPO
   dapp dimg stages pull [options] [DIMG ...] REPO
 

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

@@ -6,9 +6,7 @@ module Dapp::Dimg::CLI
           banner <<BANNER.freeze
 Usage:
 
-  dapp dimg stages cleanup local [options] [DIMG ...] [REPO]
-
-    DIMG                        Dapp image to process [default: *].
+  dapp dimg stages cleanup local [options] [REPO]
 
 Options:
 BANNER
@@ -33,7 +31,7 @@ BANNER
           def run(argv = ARGV)
             self.class.parse_options(self, argv)
             repository = repo
-            run_dapp_command(run_method, options: cli_options(dimgs_patterns: cli_arguments, repo: repository))
+            run_dapp_command(run_method, options: cli_options(repo: repository))
           end
 
           def repo

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

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

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

@@ -6,15 +6,13 @@ module Dapp::Dimg::CLI
           banner <<BANNER.freeze
 Usage:
 
-  dapp dimg stages flush local [options] [DIMG ...]
-
-    DIMG                        Dapp image to process [default: *].
+  dapp dimg stages flush local [options]
 
 Options:
 BANNER
           def run(argv = ARGV)
             self.class.parse_options(self, argv)
-            run_dapp_command(:stages_flush_local, options: cli_options(dimgs_patterns: cli_arguments))
+            run_dapp_command(:stages_flush_local, options: cli_options)
           end
         end
       end

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

@@ -6,9 +6,7 @@ module Dapp::Dimg::CLI
           banner <<BANNER.freeze
 Usage:
 
-  dapp dimg stages flush repo [options] [DIMG ...] REPO
-
-    DIMG                        Dapp image to process [default: *].
+  dapp dimg stages flush repo [options] REPO
 
 Options:
 BANNER
@@ -21,7 +19,7 @@ BANNER
           def run(argv = ARGV)
             self.class.parse_options(self, argv)
             repo = self.class.required_argument(self, 'repo')
-            run_dapp_command(:stages_flush_repo, options: cli_options(dimgs_patterns: cli_arguments, repo: repo))
+            run_dapp_command(:stages_flush_repo, options: cli_options(repo: repo))
           end
         end
       end

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

@@ -159,7 +159,7 @@ module Dapp
             if dimg_name.nil?
               spush_format
             else
-              '%{repo}:%{dimg_name}-%{tag}'
+              '%{repo}/%{dimg_name}:%{tag}'
             end
           end
 

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

@@ -45,29 +45,29 @@ module Dapp
                 log_step_with_indent(name) do
                   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) }
+                  dimgs, dimgstages = dapp_project_images.partition { |image| repo_dimgs.any? { |dimg| dimg[:id] == image[:id] } }
+                  dimgs.each { |dimg_image| except_dapp_project_image_with_parents(dimg_image[:id], dimgstages) }
 
                   # Удаление только образов старше 2ч
-                  stages.delete_if do |stage_image|
-                    Time.now - stage_image[:created_at] < 2*60*60
+                  dimgstages.delete_if do |dimgstage|
+                    Time.now - dimgstage[:created_at] < 2*60*60
                   end
 
-                  remove_project_images(stages.map { |image| image[:id]} )
+                  remove_project_images(dimgstages.map { |dimgstage| dimgstage[:id]} )
                 end
               end
             end
 
-            def except_dapp_project_image_with_parents(image_id, stages)
+            def except_dapp_project_image_with_parents(image_id, dimgstages)
               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) }
+                dapp_project_image_artifacts_ids_in_labels(image_id).each { |aiid| except_dapp_project_image_with_parents(aiid, dimgstages) }
                 iid = image_id
                 loop do
-                  stages.delete_if { |stage_image| stage_image[:id] == iid }
+                  dimgstages.delete_if { |dimgstage| dimgstage[:id] == iid }
                   break if (iid = dapp_project_image_parent_id(iid)).nil?
                 end
               else
-                stages.delete_if { |stage_image| stage_image[:id] == image_id }
+                dimgstages.delete_if { |dimgstage| dimgstage[:id] == dimgstage }
               end
             end
 

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

@@ -10,89 +10,80 @@ module Dapp
 
                 registry    = registry(repo)
                 repo_dimgs  = repo_dimgs_images(registry)
-                repo_stages = repo_stages_images(registry)
+                repo_dimgstages = repo_dimgstages_images(registry)
 
-                repo_stages.delete_if { |_, siid| repo_dimgs.values.include?(siid) } # ignoring stages with dimgs ids (v2)
+                repo_dimgstages.delete_if { |dimgstage| repo_dimgs.any? { |dimg| dimgstage[:id] == dimg[:id] } } # 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?
+                proper_repo_cache(registry, repo_dimgstages)                   if proper_cache_version?
+                repo_dimgstages_cleanup(registry, repo_dimgs, repo_dimgstages) if proper_repo_cache?
+                proper_repo_git_commit(registry)                               if proper_git_commit?
               end
             end
 
             protected
 
-            def proper_repo_cache(registry, repo_stages)
+            def proper_repo_cache(registry, repo_dimgstages)
               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) }
+                repo_dimgstages
+                  .select { |dimgstage| repo_image_dapp_cache_version_label(registry, dimgstage) != ::Dapp::BUILD_CACHE_VERSION.to_s }
+                  .each { |dimgstage| delete_repo_image(registry, dimgstage); repo_dimgstages.delete_at(repo_dimgstages.index(dimgstage)) }
               end
             end
 
-            def repo_stages_cleanup(registry, repo_dimgs, repo_stages)
+            def repo_dimgstages_cleanup(registry, repo_dimgs, repo_dimgstages)
               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) }
+                repo_dimgs.each { |dimg| except_repo_image_with_parents(registry, repo_dimgstages, dimg) }
+                repo_dimgstages.each { |dimgstage| delete_repo_image(registry, dimgstage) }
               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?
+            def except_repo_image_with_parents(registry, repo_dimgstages, repo_image)
+              repo_image_dapp_artifacts_labels(registry, repo_image).each do |aid|
+                repo_image = find_repo_image_by_id(repo_dimgstages, aid)
+                except_repo_image_with_parents(registry, repo_dimgstages, repo_image) unless repo_image.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)
+                repo_dimgstages.delete_if { |dimgstage| dimgstage[:id] == repo_image[:id] }
+                break if begin
+                  (iid = registry.image_parent_id(repo_image[:tag], repo_image[:dimg])).empty? ||
+                    (repo_image = find_repo_image_by_id(repo_dimgstages, iid)).nil?
+                end
               end
             end
 
-            def repo_image_dapp_artifacts_labels(registry, image_tag)
-              select_dapp_artifacts_ids(registry.image_labels(image_tag))
+            def repo_image_dapp_artifacts_labels(registry, repo_image)
+              select_dapp_artifacts_ids(registry.image_labels(repo_image[:tag], repo_image[:dimg]))
             end
 
-            def repo_image_dapp_cache_version_label(registry, image_tag)
-              registry.image_labels(image_tag)['dapp-cache-version']
+            def repo_image_dapp_cache_version_label(registry, repo_image)
+              registry.image_labels(repo_image[:tag], repo_image[:dimg])['dapp-cache-version']
             end
 
-            def find_image_tag_by_id(images, image_id)
-              images.each { |tag, id| return tag if id == image_id }
-              nil
+            def find_repo_image_by_id(repo_images, repo_image_id)
+              repo_images.find { |repo_image| repo_image[:id] == repo_image_id }
             end
 
             def proper_repo_git_commit(registry)
               log_proper_git_commit do
                 unproper_images = []
-                repo_dapp_dappstage_images_detailed(registry).each do |_, attrs|
-                  attrs[:labels].each do |repo_name, commit|
+                repo_detailed_dimgstage_images(registry).each do |dimgstage|
+                  dimgstage[:labels].each do |repo_name, commit|
                     next if (repo = dapp_git_repositories[repo_name]).nil?
-                    unproper_images.concat(repo_image_tags_hierarchy(registry, attrs[:id])) unless repo.commit_exists?(commit)
+                    unproper_images.concat(repo_image_tags_hierarchy(registry, dimgstage[:id])) unless repo.commit_exists?(commit)
                   end
                 end
-                remove_repo_images(registry, unproper_images.uniq)
+                remove_repo_dapp_dimgstage_images(registry, unproper_images.uniq)
               end
             end
 
-            def repo_dapp_dappstage_images_detailed(registry)
-              @repo_dapp_dappstage_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
+            def repo_detailed_dimgstage_images(registry)
+              @repo_dapp_dimgstage_images_detailed ||= begin
+                repo_dimgstages_images(registry).each do |dimgstage|
+                  image_history = registry.image_history(dimgstage[:tag], nil)
+                  dimgstage[:parent] = image_history['container_config']['Image']
+                  dimgstage[:labels] = image_history['config']['Labels']
+                end
               end
             end
 
@@ -104,18 +95,18 @@ module Dapp
                 hierarchy.concat(iids)
                 break if begin
                   iids.map! do |iid|
-                    repo_dapp_dappstage_images_detailed(registry).map { |_, attrs| attrs[:id] if attrs[:parent] == iid }.compact
+                    repo_detailed_dimgstage_images(registry).map { |dimgstage| dimgstage[:id] if dimgstage[:parent] == iid }.compact
                   end.flatten!.empty?
                 end
               end
 
-              repo_dapp_dappstage_images_detailed(registry).map { |tag, attrs| tag if hierarchy.include? attrs[:id] }.compact
+              repo_detailed_dimgstage_images(registry).map { |dimgstage| dimgstage[:tag] if hierarchy.include? dimgstage[:id] }.compact
             end
 
-            def remove_repo_images(registry, tags)
+            def remove_repo_dapp_dimgstage_images(registry, tags)
               tags.each do |tag|
                 log(tag) if log_verbose? || dry_run?
-                registry.image_delete(tag) unless dry_run?
+                registry.image_delete(tag, nil) unless dry_run?
               end
             end
           end

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

@@ -12,44 +12,52 @@ module Dapp
             end
 
             def repo_dimgs_images(registry)
-              repo_dimgs_and_stages_images(registry)[:dimgs]
+              @repo_dimgs_images ||= [].tap do |dimgs_images|
+                with_registry_wrapper do
+                  {}.tap do |dimgs_tags|
+                    dimgs_tags[nil] = registry.nameless_dimg_tags
+                    dimgs_names.each do |dimg_name|
+                      dimgs_tags[dimg_name] = registry.dimg_tags(dimg_name)
+                    end unless nameless_dimg?
+                  end.each do |dimg_name, tags|
+                    dimgs_images.concat(tags_to_repo_images(registry, tags, dimg_name))
+                  end
+                end
+              end
             end
 
-            def repo_stages_images(registry)
-              repo_dimgs_and_stages_images(registry)[:stages]
+            def repo_dimgstages_images(registry)
+              with_registry_wrapper do
+                tags_to_repo_images(registry, registry.dimgstages_tags)
+              end
             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
+            def tags_to_repo_images(registry, tags, dimg_name = nil)
+              tags.map { |tag| repo_image_format(registry, tag, dimg_name) }.compact
             end
 
-            def registry_tags(registry)
-              registry.tags
+            def with_registry_wrapper
+              yield
             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)
+            def repo_image_format(registry, tag, dimg_name = nil)
+              if (id = registry.image_id(tag, dimg_name)).nil?
+                log_warning(desc: { code: 'tag_ignored', data: { tag: tag } })
+                nil
+              else
+                { dimg: dimg_name, tag: tag, id: id }
+              end
+            end
+
+            def delete_repo_image(registry, repo_image)
               if dry_run?
-                log(image_tag)
+                log(repo_image[:tag])
               else
-                registry.image_delete(image_tag)
+                registry.image_delete(repo_image[:tag], repo_image[:dimg])
               end
             end
 
@@ -64,7 +72,7 @@ module Dapp
                   dimgs.each do |dimg|
                     [dimg, dimg.artifacts].flatten
                                           .map(&:git_artifacts).flatten
-                                          .map { |ga_artifact| repositories[ga_artifact.full_name] = ga_artifact.repo }
+                                          .map { |ga_artifact| repositories[dimgstage_ga_label(ga_artifact.paramshash)] = ga_artifact.repo }
                   end
                 end
               end

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

@@ -9,9 +9,9 @@ module Dapp
                 log_step_with_indent(option_repo) do
                   registry    = registry(option_repo)
                   repo_dimgs  = repo_dimgs_images(registry)
-                  repo_stages = repo_stages_images(registry)
+                  repo_dimgstages = repo_dimgstages_images(registry)
 
-                  repo_dimgs.merge(repo_stages).keys.each { |image_tag| delete_repo_image(registry, image_tag) }
+                  repo_dimgs.concat(repo_dimgstages).each { |repo_image| delete_repo_image(registry, repo_image) }
                 end
               end
             end

data/lib/dapp/dimg/dapp/dappfile.rb

@@ -2,6 +2,14 @@ module Dapp
   module Dimg
     module Dapp
       module Dappfile
+        def nameless_dimg?
+          dimgs_names.first.nil?
+        end
+
+        def dimgs_names
+          build_configs.map(&:_name)
+        end
+
         def build_configs
           @build_configs ||= begin
             config._dimg.select do |dimg|

data/lib/dapp/dimg/dimg.rb

@@ -3,7 +3,6 @@ module Dapp
     class Dimg
       include GitArtifact
       include Path
-      include Tags
       include Stages
 
       include Helper::Sha256
@@ -62,7 +61,7 @@ module Dapp
 
       def export!(repo, format:)
         dapp.lock("#{dapp.name}.images", readonly: true) do
-          tags.each do |tag|
+          dapp.option_tags.each do |tag|
             image_name = format(format, repo: repo, dimg_name: config._name, tag: tag)
             export_base!(last_stage.image, image_name)
           end

data/lib/dapp/dimg/docker_registry.rb

@@ -9,7 +9,7 @@ module Dapp
         if expected_hostname
           %w(https http).each do |protocol|
             expected_hostname_url = [protocol, expected_hostname].join('://')
-            return Base.new(repo, expected_hostname_url, expected_repo_suffix) if hostname_exist?(expected_hostname_url)
+            return Dimg.new(repo, expected_hostname_url, expected_repo_suffix) if hostname_exist?(expected_hostname_url)
           end
         end
         Default.new(repo, File.join(*[expected_hostname, expected_repo_suffix].compact))

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

@@ -17,12 +17,8 @@ module Dapp
           self.repo_suffix = repo_suffix
         end
 
-        def repo_exist?
-          tags.any?
-        end
-
         def tags
-          @tags ||= api_request(repo_suffix, 'tags/list')['tags'] || []
+          api_request(repo_suffix, 'tags/list')['tags'] || []
         rescue Error::Registry => e
           raise Exception::Registry, code: :no_such_dimg, data: { registry: api_url } if e.net_status[:code] == :page_not_found
           raise
@@ -86,6 +82,8 @@ module Dapp
         def raw_api_request(*uri, **options)
           url = api_url(*uri)
           request(url, **default_api_options.merge(options))
+        rescue Excon::Error::MethodNotAllowed
+          raise Error::Registry, code: :method_not_allowed, data: { url: url, registry: api_url, method: options[:method] }
         rescue Excon::Error::NotFound
           raise Error::Registry, code: :page_not_found, data: { url: url, registry: api_url }
         rescue Excon::Error::Unauthorized

data/lib/dapp/dimg/docker_registry/default.rb

@@ -1,7 +1,7 @@
 module Dapp
   module Dimg
     module DockerRegistry
-      class Default < Base
+      class Default < Dimg
         DEFAULT_HOSTNAME_URL = 'https://registry.hub.docker.com'.freeze
 
         def initialize(repo, repo_suffix)

data/lib/dapp/dimg/docker_registry/dimg.rb

@@ -0,0 +1,58 @@
+module Dapp
+  module Dimg
+    module DockerRegistry
+      class Dimg < Base
+        def dimgstages_tags
+          tags.select { |tag| tag.start_with?('dimgstage') }
+        end
+
+        def dimg_tags(dimg_name)
+          with_repo_suffix(dimg_name.to_s) { tags }
+        rescue Exception::Registry => e
+          raise unless e.net_status[:code] == :no_such_dimg
+          []
+        end
+
+        def nameless_dimg_tags
+          tags.select { |tag| !tag.start_with?('dimgstage') }
+        end
+
+        def tags
+          (@tags ||= {})[repo_suffix] ||= super
+        end
+
+        def image_id(tag, extra_repo_suffix = nil)
+          with_repo_suffix(extra_repo_suffix.to_s) { super(tag) }
+        end
+
+        def image_parent_id(tag, extra_repo_suffix = nil)
+          with_repo_suffix(extra_repo_suffix.to_s) { super(tag) }
+        end
+
+        def image_labels(tag, extra_repo_suffix = nil)
+          with_repo_suffix(extra_repo_suffix.to_s) { super(tag) }
+        end
+
+        def image_delete(tag, extra_repo_suffix = nil)
+          with_repo_suffix(extra_repo_suffix.to_s) { super(tag) }
+        end
+
+        def image_history(tag, extra_repo_suffix = nil)
+          with_repo_suffix(extra_repo_suffix.to_s) do
+            (@image_history ||= {})[[repo_suffix, tag]] ||= super(tag)
+          end
+        end
+
+        protected
+
+        def with_repo_suffix(extra_repo_suffix)
+          old_repo_suffix = repo_suffix
+          @repo_suffix = File.join(repo_suffix, extra_repo_suffix)
+          yield
+        ensure
+          @repo_suffix = old_repo_suffix
+        end
+      end
+    end # DockerRegistry
+  end # Dimg
+end # Dapp

data/lib/dapp/dimg/git_artifact.rb

@@ -16,7 +16,7 @@ module Dapp
         @repo = repo
         @name = name
 
-        @branch = branch || repo.dimg.dapp.options[:git_artifact_branch] || repo.branch
+        @branch = branch || repo.dapp.options[:git_artifact_branch] || repo.branch
         @commit = commit
 
         @to = to
@@ -67,13 +67,13 @@ module Dapp
             when :directory
               stage.image.add_service_change_label :"dapp-git-#{paramshash}-type" => 'directory'
 
-              commands << "#{repo.dimg.dapp.install_bin} #{credentials.join(' ')} -d \"#{to}\""
-              commands << "#{sudo}#{repo.dimg.dapp.tar_bin} -xf #{archive_file(stage, *archive_stage_commit(stage))} -C \"#{to}\""
+              commands << "#{repo.dapp.install_bin} #{credentials.join(' ')} -d \"#{to}\""
+              commands << "#{sudo}#{repo.dapp.tar_bin} -xf #{archive_file(stage, *archive_stage_commit(stage))} -C \"#{to}\""
             when :file
               stage.image.add_service_change_label :"dapp-git-#{paramshash}-type" => 'file'
 
-              commands << "#{repo.dimg.dapp.install_bin} #{credentials.join(' ')} -d \"#{File.dirname(to)}\""
-              commands << "#{sudo}#{repo.dimg.dapp.tar_bin} -xf #{archive_file(stage, *archive_stage_commit(stage))} -C \"#{File.dirname(to)}\""
+              commands << "#{repo.dapp.install_bin} #{credentials.join(' ')} -d \"#{File.dirname(to)}\""
+              commands << "#{sudo}#{repo.dapp.tar_bin} -xf #{archive_file(stage, *archive_stage_commit(stage))} -C \"#{File.dirname(to)}\""
             end
           end
         end
@@ -90,13 +90,13 @@ module Dapp
               case archive_type
               when :directory
                 changed_files = diff_patches(*dev_patch_stage_commits(stage)).map {|p| "\"#{File.join(to, cwd, p.delta.new_file[:path])}\""}
-                commands << "#{repo.dimg.dapp.rm_bin} -rf #{changed_files.join(' ')}"
-                commands << "#{repo.dimg.dapp.install_bin} #{credentials.join(' ')} -d \"#{to}\""
-                commands << "#{sudo}#{repo.dimg.dapp.tar_bin} -xf #{archive_file(stage, *dev_patch_stage_commits(stage))} -C \"#{to}\""
+                commands << "#{repo.dapp.rm_bin} -rf #{changed_files.join(' ')}"
+                commands << "#{repo.dapp.install_bin} #{credentials.join(' ')} -d \"#{to}\""
+                commands << "#{sudo}#{repo.dapp.tar_bin} -xf #{archive_file(stage, *dev_patch_stage_commits(stage))} -C \"#{to}\""
               when :file
-                commands << "#{repo.dimg.dapp.rm_bin} -rf \"#{to}\""
-                commands << "#{repo.dimg.dapp.install_bin} #{credentials.join(' ')} -d \"#{File.dirname(to)}\""
-                commands << "#{sudo}#{repo.dimg.dapp.tar_bin} -xf #{archive_file(stage, *dev_patch_stage_commits(stage))} -C \"#{File.dirname(to)}\""
+                commands << "#{repo.dapp.rm_bin} -rf \"#{to}\""
+                commands << "#{repo.dapp.install_bin} #{credentials.join(' ')} -d \"#{File.dirname(to)}\""
+                commands << "#{sudo}#{repo.dapp.tar_bin} -xf #{archive_file(stage, *dev_patch_stage_commits(stage))} -C \"#{File.dirname(to)}\""
               else
                 raise
               end
@@ -105,11 +105,11 @@ module Dapp
             if patch_any_changes?(stage)
               case archive_type
               when :directory
-                commands << "#{repo.dimg.dapp.install_bin} #{credentials.join(' ')} -d \"#{to}\""
-                commands << "#{sudo}#{repo.dimg.dapp.git_bin} apply --whitespace=nowarn --directory=\"#{to}\" --unsafe-paths #{patch_file(stage, *patch_stage_commits(stage))}"
+                commands << "#{repo.dapp.install_bin} #{credentials.join(' ')} -d \"#{to}\""
+                commands << "#{sudo}#{repo.dapp.git_bin} apply --whitespace=nowarn --directory=\"#{to}\" --unsafe-paths #{patch_file(stage, *patch_stage_commits(stage))}"
               when :file
-                commands << "#{repo.dimg.dapp.install_bin} #{credentials.join(' ')} -d \"#{File.dirname(to)}\""
-                commands << "#{sudo}#{repo.dimg.dapp.git_bin} apply --whitespace=nowarn --directory=\"#{File.dirname(to)}\" --unsafe-paths #{patch_file(stage, *patch_stage_commits(stage))}"
+                commands << "#{repo.dapp.install_bin} #{credentials.join(' ')} -d \"#{File.dirname(to)}\""
+                commands << "#{sudo}#{repo.dapp.git_bin} apply --whitespace=nowarn --directory=\"#{File.dirname(to)}\" --unsafe-paths #{patch_file(stage, *patch_stage_commits(stage))}"
               else
                 raise
               end
@@ -129,9 +129,9 @@ module Dapp
         @stage_dependencies_checksums ||= {}
         @stage_dependencies_checksums[stage_dependencies_key] ||= begin
           if (entries = repo_entries(commit, paths: paths)).empty?
-            repo.dimg.dapp.log_warning(desc: { code: :stage_dependencies_not_found,
-                                               data: { repo: repo.respond_to?(:url) ? repo.url : 'local',
-                                                       dependencies: stage_dependencies.join(', ') } })
+            repo.dapp.log_warning(desc: { code: :stage_dependencies_not_found,
+                                          data: { repo: repo.respond_to?(:url) ? repo.url : 'local',
+                                                  dependencies: stage_dependencies.join(', ') } })
           end
 
           entries
@@ -203,7 +203,7 @@ module Dapp
       attr_reader :stages_dependencies
 
       def sudo
-        repo.dimg.dapp.sudo_command(owner: owner, group: group)
+        repo.dapp.sudo_command(owner: owner, group: group)
       end
 
       def credentials
@@ -211,7 +211,7 @@ module Dapp
       end
 
       def archive_file(stage, commit)
-        if repo.dimg.dapp.options[:use_system_tar]
+        if repo.dapp.options[:use_system_tar]
           archive_file_with_system_tar(stage, commit)
         else
           archive_file_with_tar_writer(stage, commit)
@@ -249,7 +249,7 @@ module Dapp
             end
           end
 
-          repo.dimg.dapp.shellout!("tar -C #{repo.dimg.tmp_path(relative_archive_file_path)} -cf #{archive_path} .")
+          repo.dapp.shellout!("tar -C #{repo.dimg.tmp_path(relative_archive_file_path)} -cf #{archive_path} .")
         end
       end
 

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

@@ -3,14 +3,33 @@ module Dapp
     module GitRepo
       # Base class for any Git repo (remote, gitkeeper, etc)
       class Base
-        attr_reader :dimg
         attr_reader :name
 
-        def initialize(dimg, name)
-          @dimg = dimg
+        def initialize(manager, name)
+          @manager = manager
           @name = name
         end
 
+        def dapp
+          @dapp ||= begin
+            if manager.is_a? ::Dapp::Dapp
+              manager
+            else
+              dimg.dapp
+            end
+          end
+        end
+
+        def dimg
+          @dimg ||= begin
+            if manager.is_a? ::Dapp::Dimg::Dimg
+              manager
+            else
+              raise
+            end
+          end
+        end
+
         def exclude_paths
           []
         end
@@ -92,6 +111,8 @@ module Dapp
 
         protected
 
+        attr_reader :manager
+
         def git(**kwargs)
           @git ||= Rugged::Repository.new(path.to_s, **kwargs)
         end

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

@@ -2,12 +2,12 @@ module Dapp
   module Dimg
     module GitRepo
       class Own < Base
-        def initialize(dimg)
-          super(dimg, 'own')
+        def initialize(manager)
+          super(manager, 'own')
         end
 
         def exclude_paths
-          dimg.dapp.local_git_artifact_exclude_paths
+          dapp.local_git_artifact_exclude_paths
         end
 
         def workdir_path
@@ -15,7 +15,7 @@ module Dapp
         end
 
         def path
-          @path ||= Pathname(Rugged::Repository.discover(dimg.home_path.to_s).path)
+          @path ||= Pathname(Rugged::Repository.discover(dapp.path.to_s).path)
         rescue Rugged::RepositoryError => _e
           raise Error::Rugged, code: :local_git_repository_does_not_exist
         end

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

@@ -9,7 +9,7 @@ module Dapp
 
           @url = url
 
-          dimg.dapp.log_secondary_process(dimg.dapp.t(code: 'process.git_artifact_clone', data: { url: url }), short: true) do
+          dapp.log_secondary_process(dapp.t(code: 'process.git_artifact_clone', data: { url: url }), short: true) do
             begin
               if [:https, :ssh].include?(protocol) && !Rugged.features.include?(protocol)
                 raise Error::Rugged, code: :rugged_protocol_not_supported, data: { url: url, protocol: protocol }
@@ -38,10 +38,10 @@ module Dapp
 
         def fetch!(branch = nil)
           branch ||= self.branch
-          dimg.dapp.log_secondary_process(dimg.dapp.t(code: 'process.git_artifact_fetch', data: { url: url }), short: true) do
+          dapp.log_secondary_process(dapp.t(code: 'process.git_artifact_fetch', data: { url: url }), short: true) do
             git.fetch('origin', [branch], credentials: _rugged_credentials)
             raise Error::Rugged, code: :branch_not_exist_in_remote_git_repository, data: { branch: branch, url: url } unless branch_exist?(branch)
-          end unless dimg.ignore_git_fetch || dimg.dapp.dry_run?
+          end unless dimg.ignore_git_fetch || dapp.dry_run?
         end
 
         def branch_exist?(name)

data/lib/dapp/kube/cli/command/kube/deploy.rb

@@ -12,9 +12,31 @@ BANNER
              long: '--namespace NAME',
              default: nil
 
-      option :image_version,
-             long: '--image-version IMAGE_VERSION',
-             default: 'latest'
+      option :tag,
+             long: '--tag TAG',
+             description: 'Custom tag',
+             default: [],
+             proc: proc { |v| composite_options(:tags) << v }
+
+      option :tag_branch,
+             long: '--tag-branch',
+             description: 'Tag by git branch',
+             boolean: true
+
+      option :tag_build_id,
+             long: '--tag-build-id',
+             description: 'Tag by CI build id',
+             boolean: true
+
+      option :tag_ci,
+             long: '--tag-ci',
+             description: 'Tag by CI branch and tag',
+             boolean: true
+
+      option :tag_commit,
+             long: '--tag-commit',
+             description: 'Tag by git commit',
+             boolean: true
 
       option :tmp_dir_prefix,
              long: '--tmp-dir-prefix PREFIX',

data/lib/dapp/kube/cli/command/kube/lint.rb

@@ -10,27 +10,49 @@ Options:
 BANNER
 
       option :namespace,
-        long: '--namespace NAME',
-        default: nil
+             long: '--namespace NAME',
+             default: nil
 
-      option :image_version,
-        long: '--image-version IMAGE_VERSION',
-        default: 'latest'
+      option :tag,
+             long: '--tag TAG',
+             description: 'Custom tag',
+             default: [],
+             proc: proc { |v| composite_options(:tags) << v }
+
+      option :tag_branch,
+             long: '--tag-branch',
+             description: 'Tag by git branch',
+             boolean: true
+
+      option :tag_build_id,
+             long: '--tag-build-id',
+             description: 'Tag by CI build id',
+             boolean: true
+
+      option :tag_ci,
+             long: '--tag-ci',
+             description: 'Tag by CI branch and tag',
+             boolean: true
+
+      option :tag_commit,
+             long: '--tag-commit',
+             description: 'Tag by git commit',
+             boolean: true
 
       option :helm_set_options,
-        long: '--set STRING_ARRAY',
-        default: [],
-        proc: proc { |v| composite_options(:helm_set) << v }
+             long: '--set STRING_ARRAY',
+             default: [],
+             proc: proc { |v| composite_options(:helm_set) << v }
 
       option :helm_values_options,
-        long: '--values FILE_PATH',
-        default: [],
-        proc: proc { |v| composite_options(:helm_values) << v }
+             long: '--values FILE_PATH',
+             default: [],
+             proc: proc { |v| composite_options(:helm_values) << v }
 
       option :helm_secret_values_options,
-        long: '--secret-values FILE_PATH',
-        default: [],
-        proc: proc { |v| composite_options(:helm_secret_values) << v }
+             long: '--secret-values FILE_PATH',
+             default: [],
+             proc: proc { |v| composite_options(:helm_secret_values) << v }
 
       def run(argv = ARGV)
         self.class.parse_options(self, argv)

data/lib/dapp/kube/cli/command/kube/render.rb

@@ -12,9 +12,31 @@ BANNER
              long: '--namespace NAME',
              default: nil
 
-      option :image_version,
-             long: '--image-version IMAGE_VERSION',
-             default: 'latest'
+      option :tag,
+             long: '--tag TAG',
+             description: 'Custom tag',
+             default: [],
+             proc: proc { |v| composite_options(:tags) << v }
+
+      option :tag_branch,
+             long: '--tag-branch',
+             description: 'Tag by git branch',
+             boolean: true
+
+      option :tag_build_id,
+             long: '--tag-build-id',
+             description: 'Tag by CI build id',
+             boolean: true
+
+      option :tag_ci,
+             long: '--tag-ci',
+             description: 'Tag by CI branch and tag',
+             boolean: true
+
+      option :tag_commit,
+             long: '--tag-commit',
+             description: 'Tag by git commit',
+             boolean: true
 
       option :tmp_dir_prefix,
              long: '--tmp-dir-prefix PREFIX',

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

@@ -9,9 +9,13 @@ module Dapp
             kube_check_helm_chart!
 
             repo = option_repo
-            image_version = options[:image_version]
+            tag = begin
+              raise Error::Command, code: :expected_only_one_tag,
+                                    data: { tags: option_tags.join(', ') } if option_tags.count > 1
+              option_tags.first
+            end
             validate_repo_name!(repo)
-            validate_tag_name!(image_version)
+            validate_tag_name!(tag)
 
             with_kube_tmp_chart_dir do
               kube_copy_chart
@@ -22,7 +26,7 @@ module Dapp
                   self,
                   name: kube_release_name,
                   repo: repo,
-                  image_version: image_version,
+                  docker_tag: tag,
                   namespace: kube_namespace,
                   chart_path: kube_chart_path_for_helm,
                   set: self.options[:helm_set_options],
@@ -92,10 +96,10 @@ module Dapp
 {{- if (ge (len (index .)) 2) -}}
 {{- $name := index . 0 -}}
 {{- $context := index . 1 -}}
-{{- printf "%v:%v-%v" $context.Values.global.dapp.repo $name $context.Values.global.dapp.image_version -}}
+{{- printf "%v/%v:%v" $context.Values.global.dapp.repo $name $context.Values.global.dapp.docker_tag -}}
 {{- else -}}
 {{- $context := index . 0 -}}
-{{- printf "%v:%v" $context.Values.global.dapp.repo $context.Values.global.dapp.image_version -}}
+{{- printf "%v:%v" $context.Values.global.dapp.repo $context.Values.global.dapp.docker_tag -}}
 {{- end -}}
 {{- end -}}
 

data/lib/dapp/kube/dapp/command/lint.rb

@@ -31,7 +31,7 @@ module Dapp
             kube_check_helm_chart!
 
             repo = option_repo
-            image_version = options[:image_version]
+            docker_tag = options[:docker_tag]
 
             with_kube_tmp_lint_chart_dir do
               kube_copy_chart
@@ -61,8 +61,8 @@ module Dapp
               all_values['global'] = {
                 'namespace' => kube_namespace,
                 'dapp' => {
-                  'repo' => option_repo,
-                  'image_version' => options[:image_version]
+                  'repo' => repo,
+                  'docker_tag' => docker_tag
                 }
               }
 

data/lib/dapp/kube/helm/release.rb

@@ -7,7 +7,7 @@ module Dapp
 
       attr_reader :name
       attr_reader :repo
-      attr_reader :image_version
+      attr_reader :docker_tag
       attr_reader :namespace
       attr_reader :chart_path
       attr_reader :set
@@ -15,13 +15,13 @@ module Dapp
       attr_reader :deploy_timeout
 
       def initialize(dapp,
-        name:, repo:, image_version:, namespace:, chart_path:,
+        name:, repo:, docker_tag:, namespace:, chart_path:,
         set: [], values: [], deploy_timeout: nil)
         @dapp = dapp
 
         @name = name
         @repo = repo
-        @image_version = image_version
+        @docker_tag = docker_tag
         @namespace = namespace
         @chart_path = chart_path
         @set = set
@@ -119,7 +119,7 @@ module Dapp
         [].tap do |options|
           options.concat(set.map { |opt| "--set #{opt}" })
           options << "--set global.dapp.repo=#{repo}"
-          options << "--set global.dapp.image_version=#{image_version}"
+          options << "--set global.dapp.docker_tag=#{docker_tag}"
           options << "--set global.namespace=#{namespace}"
         end
       end

data/lib/dapp/version.rb

@@ -1,4 +1,4 @@
 module Dapp
-  VERSION = '0.20.0'.freeze
+  VERSION = '0.21.0'.freeze
   BUILD_CACHE_VERSION = 23
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dapp
 version: !ruby/object:Gem::Version
-  version: 0.20.0
+  version: 0.21.0
 platform: ruby
 authors:
 - Dmitry Stolyarov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-24 00:00:00.000000000 Z
+date: 2017-11-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mixlib-shellout
@@ -444,6 +444,7 @@ files:
 - lib/dapp/dapp/logging/i18n.rb
 - lib/dapp/dapp/logging/paint.rb
 - lib/dapp/dapp/logging/process.rb
+- lib/dapp/dapp/option_tags.rb
 - lib/dapp/dapp/shellout/base.rb
 - lib/dapp/dapp/shellout/streaming.rb
 - lib/dapp/dapp/ssh_agent.rb
@@ -595,12 +596,12 @@ files:
 - lib/dapp/dimg/dimg/git_artifact.rb
 - lib/dapp/dimg/dimg/path.rb
 - lib/dapp/dimg/dimg/stages.rb
-- lib/dapp/dimg/dimg/tags.rb
 - lib/dapp/dimg/docker_registry.rb
 - lib/dapp/dimg/docker_registry/base.rb
 - lib/dapp/dimg/docker_registry/base/authorization.rb
 - lib/dapp/dimg/docker_registry/base/request.rb
 - lib/dapp/dimg/docker_registry/default.rb
+- lib/dapp/dimg/docker_registry/dimg.rb
 - lib/dapp/dimg/error/base.rb
 - lib/dapp/dimg/error/build.rb
 - lib/dapp/dimg/error/chef.rb

data/lib/dapp/dimg/dimg/tags.rb

@@ -1,65 +0,0 @@
-module Dapp
-  module Dimg
-    class Dimg
-      module Tags
-        protected
-
-        def git_repo
-          @git_repo ||= GitRepo::Own.new(self)
-        end
-
-        def tags
-          tags = simple_tags + branch_tags + commit_tags + build_tags + ci_tags
-          tags << :latest if tags.empty?
-          tags
-        end
-
-        def simple_tags
-          dapp.options[:tag]
-        end
-
-        def branch_tags
-          return [] unless dapp.options[:tag_branch]
-          raise Error::Dimg, code: :git_branch_without_name if (branch = git_repo.branch) == 'HEAD'
-          [branch]
-        end
-
-        def commit_tags
-          return [] unless dapp.options[:tag_commit]
-          commit = git_repo.latest_commit
-          [commit]
-        end
-
-        def build_tags
-          return [] unless dapp.options[:tag_build_id]
-
-          if ENV['GITLAB_CI']
-            build_id = ENV['CI_BUILD_ID']
-          elsif ENV['TRAVIS']
-            build_id = ENV['TRAVIS_BUILD_NUMBER']
-          else
-            raise Error::Dimg, code: :ci_environment_required
-          end
-
-          [build_id]
-        end
-
-        def ci_tags
-          return [] unless dapp.options[:tag_ci]
-
-          if ENV['GITLAB_CI']
-            branch = ENV['CI_BUILD_REF_NAME']
-            tag = ENV['CI_BUILD_TAG']
-          elsif ENV['TRAVIS']
-            branch = ENV['TRAVIS_BRANCH']
-            tag = ENV['TRAVIS_TAG']
-          else
-            raise Error::Dimg, code: :ci_environment_required
-          end
-
-          [branch, tag].compact
-        end
-      end # Tags
-    end # Mod
-  end # Dimg
-end # Dapp