dapp 0.34.7 → 0.35.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5cb59dc0c1ac431b394689bb1a3e8ebdddbf39da9ff360ece1e8c352a1bdfe1
-  data.tar.gz: 4f8a89d6268fd9bc4e27cc50131fda4b1704c6379d2d6456c3b74b1ee8c80074
+  metadata.gz: 59c94384729263dd6beae2c0cfcbd75f09010d43f334726ad53f561e70f43e93
+  data.tar.gz: ea069cf6302db1aaf1e90291299f9dbf1887f06f091afd4a7bdf9beaaba7be25
 SHA512:
-  metadata.gz: 5cf0708e76a7e2b4af0a7d8dccf618c329eda05c65cf0573acef669b110eb7628d72a2b73f24485b5f54afaf1a3dd2e9403ba4719bbdd6823922abc378fb5ddc
-  data.tar.gz: 234bf91076f193b3dd5d68797462e72aed728634f5114dafa8426ab2be1ce4e61de42f45d3682c07fdf09573c87feb79560a3f8e1d7bd6d99c6c5052ec5fd2ee
+  metadata.gz: 06f26d814a0f747fd4a40b7dc17d63896bfaf15dcd748a8bd1c7a467dde708bedc43726ab120cb8027e6f7ac1b832eae354c6ede5d9010bc402922981d5fe190
+  data.tar.gz: 89517f7d50bef08d1d62f9f6fdd73de52068a7097f770326344f4b1b956a42d1517f482c8cb6d0591c465e86c043ee97edcfeaac9dcfc9be6641564d56c78a09

data/bin/dapp

@@ -74,29 +74,7 @@ set_gitlab_cancel_handler if ENV["GITLAB_CI"]
 begin
   begin
     begin
-      begin
-        Dapp::CLI.new.run
-      ensure
-        if Time.now.to_date < Date.parse("2019-11-01")
-          STDERR.puts
-          STDERR.puts ::Paint["###################################################################", :red, :bold]
-          STDERR.puts ::Paint["###                   DEPRECATION WARNING!                      ###", :red, :bold]
-          STDERR.puts ::Paint["###  Dapp will be deprecated for use starting with 01.11.2019!  ###", :red, :bold]
-          STDERR.puts ::Paint["###            Please port your project to werf:                ###", :red, :bold]
-          STDERR.puts ::Paint["###                     https://werf.io                         ###", :red, :bold]
-          STDERR.puts ::Paint["###################################################################", :red, :bold]
-          STDERR.puts
-        else
-          STDERR.puts
-          STDERR.puts ::Paint["######################################################################", :red, :bold]
-          STDERR.puts ::Paint["###                     DEPRECATION WARNING!                       ###", :red, :bold]
-          STDERR.puts ::Paint["###  Dapp is deprecated for use and will not receive any support!  ###", :red, :bold]
-          STDERR.puts ::Paint["###               Please port your project to werf:                ###", :red, :bold]
-          STDERR.puts ::Paint["###                       https://werf.io                          ###", :red, :bold]
-          STDERR.puts ::Paint["######################################################################", :red, :bold]
-          STDERR.puts
-        end
-      end
+      Dapp::CLI.new.run
     rescue Dapp::Error::Base => e
       unless (message = Dapp::Helper::NetStatus.before_error_message(e)).empty?
         $stderr.puts(message)

data/config/en/net_status.yml

@@ -122,11 +122,7 @@ en:
       builder_cookbook_not_found: "Dapp cookbook directory not found at %{path}"
       berksfile_absolute_path_forbidden: "Absolute paths in Berksfile are not allowed (cookbook `%{cookbook}`, path: `%{path}`)"
     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!'
-      registry_not_available: 'Registry `%{registry}`: not available!'
+      ruby2go_docker_registry_command_failed_unexpected_error: 'ruby2go_docker_registry command `%{command}` failed: `%{message}`!'
     rugged:
       git_repository_reference_error: "Git repo `%{name}`: %{message}!"
       rugged_remote_error: "Remote git repo `%{url}`: `%{message}`!"

data/lib/dapp.rb

@@ -266,12 +266,8 @@ require 'dapp/dimg/dapp/dimg'
 require 'dapp/dimg/dapp/config_artifact_group'
 require 'dapp/dimg/dapp/dapp'
 require 'dapp/dimg/docker_registry'
-require 'dapp/dimg/docker_registry/error'
-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/lock/base'
 require 'dapp/dimg/lock/file'
 require 'dapp/dimg/filelock'

data/lib/dapp/dapp.rb

@@ -237,9 +237,10 @@ module Dapp
       end
 
       def docker_credentials
-        if options.key?(:registry_username) && options.key?(:registry_password)
+        if options[:registry_username] && options[:registry_password]
           [options[:registry_username], options[:registry_password]]
-        elsif ENV.key?('CI_JOB_TOKEN')
+        elsif ENV.key?('DAPP_DOCKER_CONFIG')
+        elsif !ENV.key?('DAPP_IGNORE_CI_DOCKER_AUTOLOGIN') && ENV.key?('CI_JOB_TOKEN')
           ['gitlab-ci-token', ENV['CI_JOB_TOKEN']]
         end
       end

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

@@ -16,7 +16,7 @@ module Dapp
 
         def dimg_registry(repo = option_repo)
           validate_repo_name!(repo)
-          ::Dapp::Dimg::DockerRegistry.new(repo)
+          ::Dapp::Dimg::DockerRegistry.new(self, repo)
         end
       end
     end

data/lib/dapp/dapp/ruby2go.rb

@@ -5,6 +5,10 @@ module Dapp
         _ruby2go("image", args_hash)
       end
 
+      def ruby2go_docker_registry(args_hash)
+        _ruby2go("docker_registry", args_hash)
+      end
+
       def ruby2go_builder(args_hash)
         _ruby2go("builder", args_hash)
       end

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

@@ -113,6 +113,7 @@ module Dapp
             image.add_service_change_label dapp: dimg.stage_dapp_label
             image.add_service_change_label 'dapp-version'.to_sym => ::Dapp::VERSION
             image.add_service_change_label 'dapp-cache-version'.to_sym => ::Dapp::BUILD_CACHE_VERSION
+            image.add_service_change_label 'dapp-dimg'.to_sym => false
             image.add_service_change_label 'dapp-dev-mode'.to_sym => true if dimg.dev_mode?
 
             if dimg.dapp.ssh_auth_sock

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

@@ -39,7 +39,7 @@ BANNER
         def run(argv = ARGV)
           self.class.parse_options(self, argv)
           repo = self.class.required_argument(self, 'repo')
-          run_dapp_command(run_method, options: cli_options(dimgs_patterns: cli_arguments, repo: repo, verbose: true))
+          run_dapp_command(run_method, options: cli_options(dimgs_patterns: cli_arguments, repo: repo, verbose: true), try_host_docker_login: true)
         end
       end
     end

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

@@ -28,7 +28,7 @@ BANNER
         def run(argv = ARGV)
           self.class.parse_options(self, argv)
           repo = self.class.required_argument(self, 'repo')
-          run_dapp_command(run_method, options: cli_options(dimgs_patterns: cli_arguments, repo: repo, verbose: true))
+          run_dapp_command(run_method, options: cli_options(dimgs_patterns: cli_arguments, repo: repo, verbose: true), try_host_docker_login: true)
         end
       end
     end

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

@@ -31,7 +31,7 @@ BANNER
           def run(argv = ARGV)
             self.class.parse_options(self, argv)
             repository = repo
-            run_dapp_command(run_method, options: cli_options(repo: repository))
+            run_dapp_command(run_method, options: cli_options(repo: repository), try_host_docker_login: true)
           end
 
           def repo

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

@@ -19,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(repo: repo))
+            run_dapp_command(:stages_flush_repo, options: cli_options(repo: repo), try_host_docker_login: true)
           end
         end
       end

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

@@ -225,65 +225,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/stages/cleanup_repo.rb

@@ -55,11 +55,11 @@ module Dapp
             end
 
             def repo_image_dapp_artifacts_labels(registry, repo_image)
-              select_dapp_artifacts_ids(registry.image_labels(repo_image[:tag], repo_image[:dimg]))
+              select_dapp_artifacts_ids(registry.image_config(repo_image[:tag], repo_image[:dimg])["config"]["Labels"])
             end
 
             def repo_image_dapp_cache_version_label(registry, repo_image)
-              registry.image_labels(repo_image[:tag], repo_image[:dimg])['dapp-cache-version']
+              registry.image_config(repo_image[:tag], repo_image[:dimg])["config"]["Labels"]['dapp-cache-version']
             end
 
             def repo_image_by_id(repo_image_id, repo_images)
@@ -82,9 +82,9 @@ module Dapp
             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']
+                  image_config = registry.image_config(dimgstage[:tag], nil)
+                  dimgstage[:parent] = image_config["container_config"]["Image"]
+                  dimgstage[:labels] = image_config["config"]["Labels"]
                 end
               end
             end

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

@@ -9,13 +9,14 @@ module Dapp
             def repo_detailed_dimgs_images(registry)
               repo_dimgs_images(registry).select do |dimg|
                 begin
-                  image_history = registry.image_history(dimg[:tag], dimg[:dimg])
-                  dimg[:created_at] = Time.parse(image_history['created']).to_i
-                  dimg[:parent] = image_history['container_config']['Image']
-                  dimg[:labels] = image_history['config']['Labels'] || {}
+                  image_config = registry.image_config(dimg[:tag], dimg[:dimg])
+                  dimg[:created_at] = Time.parse(image_config["created"]).to_i
+                  dimg[:parent] = image_config["container_config"]["Image"]
+                  dimg[:labels] = image_config["config"]["Labels"]
                   dimg[:labels]['dapp'] == name
-                rescue ::Dapp::Dimg::DockerRegistry::Error::ManifestInvalid => err
-                  log_warning "WARNING: Ignore dimg `#{dimg[:dimg]}` tag `#{dimg[:tag]}`: got manifest-invalid-error from docker registry: #{err.message}"
+                rescue ::Dapp::Dimg::Error::Registry => e
+                  raise unless e.net_status[:data][:message].include?("MANIFEST_UNKNOWN")
+                  log_warning "WARNING: Ignore dimg `#{dimg[:dimg]}` tag `#{dimg[:tag]}`: got manifest-invalid-error from docker registry: #{e.net_status[:data][:message]}"
                   false
                 end
               end
@@ -52,8 +53,9 @@ module Dapp
                 end
 
                 return { dimg: dimg_name, tag: tag, id: id }
-              rescue ::Dapp::Dimg::DockerRegistry::Error::ImageNotFound => err
-                log_warning "WARNING: Ignore dimg `#{dimg_name}` tag `#{tag}`: got not-found-error from docker registry on get-image-manifest request: #{err.message}"
+              rescue ::Dapp::Dimg::Error::Registry => e
+                raise unless e.net_status[:data][:message].include?("MANIFEST_UNKNOWN")
+                log_warning "WARNING: Ignore dimg `#{dimg_name}` tag `#{tag}`: got not-found-error from docker registry on get-image-manifest request: #{e.net_status[:data][:message]}"
                 return nil
               end
             end
@@ -63,8 +65,9 @@ module Dapp
               unless dry_run?
                 begin
                   registry.image_delete(repo_image[:tag], repo_image[:dimg])
-                rescue ::Dapp::Dimg::DockerRegistry::Error::ImageNotFound => err
-                  log_warning "WARNING: Ignore dimg `#{repo_image[:dimg]}` tag `#{repo_image[:tag]}`: got not-found-error from docker registry on image-delete request: #{err.message}"
+                rescue ::Dapp::Dimg::Error::Registry => e
+                  raise unless e.net_status[:data][:message].include?("MANIFEST_UNKNOWN")
+                  log_warning "WARNING: Ignore dimg `#{repo_image[:dimg]}` tag `#{repo_image[:tag]}`: got not-found-error from docker registry on image-delete request: #{e.net_status[:data][:message]}"
                 end
               end
             end

data/lib/dapp/dimg/dimg.rb

@@ -126,7 +126,7 @@ module Dapp
 
       def tag_should_not_be_pushed?(tag)
         registry_tags.include?(tag) && begin
-          registry_tag_parent = registry.image_history(tag, name)['container_config']['Image']
+          registry_tag_parent = registry.image_parent_id(tag, name)
           registry_tag_parent == last_stage.image.built_id
         end
       end

data/lib/dapp/dimg/docker_registry.rb

@@ -1,20 +1,8 @@
 module Dapp
   module Dimg
     module DockerRegistry
-      def self.new(repo)
-        /^#{repo_name_format}$/ =~ repo
-        expected_hostname = Regexp.last_match(:hostname)
-        expected_repo_suffix = Regexp.last_match(:repo_suffix)
-
-        if expected_hostname
-          %w(https http).each do |protocol|
-            expected_hostname_url = [protocol, expected_hostname].join('://')
-            return Dimg.new(repo, expected_hostname_url, expected_repo_suffix) if hostname_exist?(expected_hostname_url)
-          end
-          raise ::Dapp::Dimg::Error::Registry, code: :registry_not_available, data: { registry: repo }
-        else
-          Default.new(repo, expected_repo_suffix)
-        end
+      def self.new(dapp, repo)
+        Dimg.new(dapp, repo)
       end
 
       def self.repo_name_format
@@ -26,11 +14,6 @@ module Dapp
       def self.repo_name?(name)
         !(/^#{repo_name_format}$/ =~ name).nil?
       end
-
-      def self.hostname_exist?(url)
-        return false unless url
-        Base.url_available?(url)
-      end
     end # DockerRegistry
   end # Dimg
 end # Dapp

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

@@ -2,109 +2,51 @@ module Dapp
   module Dimg
     module DockerRegistry
       class Base
-        include Request
-        include Authorization
+        attr_accessor :dapp
+        attr_accessor :repository
 
-        API_VERSION = 'v2'.freeze
-
-        attr_accessor :repo
-        attr_accessor :hostname_url
-        attr_accessor :repo_suffix
-
-        def initialize(repo, hostname_url, repo_suffix)
-          self.repo = repo
-          self.hostname_url = hostname_url
-          self.repo_suffix = repo_suffix
-        end
-
-        def tags
-          api_request(repo_suffix, 'tags/list')['tags'] || []
+        def initialize(dapp, repository)
+          self.dapp = dapp
+          self.repository = repository
         end
 
         def image_id(tag)
-          response = manifest_v2(tag)
-          response['config']['digest'] if response['schemaVersion'] == 2
+          ruby2go_docker_registry_command(command: :image_id, options: { reference: tag_reference(tag) })
         end
 
         def image_parent_id(tag)
-          image_history(tag)['container_config']['Image']
+          ruby2go_docker_registry_command(command: :image_parent_id, options: { reference: tag_reference(tag) })
         end
 
-        def image_labels(tag)
-          image_history(tag)['config']['Labels']
+        def image_config(tag)
+          ruby2go_docker_registry_command(command: :image_config, options: { reference: tag_reference(tag) })
         end
 
         def image_delete(tag)
-          api_request(repo_suffix, "/manifests/#{image_digest(tag)}",
-                      method: :delete,
-                      expects: [202, 404],
-                      headers: { Accept: 'application/vnd.docker.distribution.manifest.v2+json' })
+          digest = image_digest(tag)
+          ruby2go_docker_registry_command(command: :image_delete, options: { reference: digest_reference(digest) })
         end
 
-        def image_history(tag)
-          response = manifest_v1(tag)
-          JSON.load(response['history'].first['v1Compatibility'])
-        end
-
-        protected
-
         def image_digest(tag)
-          raw_api_request(repo_suffix, "/manifests/#{tag}",
-                          headers: { Accept: 'application/vnd.docker.distribution.manifest.v2+json' }).headers['Docker-Content-Digest']
+          ruby2go_docker_registry_command(command: :image_digest, options: { reference: tag_reference(tag) })
         end
 
-        def manifest_v1(tag)
-          api_request(repo_suffix, "/manifests/#{tag}")
-        end
+        protected
 
-        def manifest_v2(tag)
-          api_request(repo_suffix, "/manifests/#{tag}",
-                      headers: { Accept: 'application/vnd.docker.distribution.manifest.v2+json' })
+        def tag_reference(tag = nil)
+          [self.repository.chomp("/"), tag].compact.join(":")
         end
 
-        def api_request(*uri, **options)
-          JSON.load(raw_api_request(*uri, **options).body)
+        def digest_reference(digest = nil)
+          [self.repository.chomp("/"), digest].compact.join("@")
         end
 
-        def raw_api_request(*uri, **options)
-          url = api_url(*uri)
-          request(url, **default_api_options.merge(options))
-        rescue Excon::Error::MethodNotAllowed
-          raise ::Dapp::Dimg::DockerRegistry::Error::Base, code: :method_not_allowed, data: { url: url, registry: api_url, method: options[:method] }
-        rescue Excon::Error::NotFound
-          raise ::Dapp::Dimg::DockerRegistry::Error::ImageNotFound.new(url, api_url)
-        rescue Excon::Error::Unauthorized
-          user_not_authorized!
-        rescue Excon::Error => err
-          if err.is_a? Excon::Error::BadRequest
-            response_data = (JSON.load(err.response.body) rescue nil)
-            if response_data
-              (response_data["errors"] || []).each do |err_data|
-                if err_data["code"] == "MANIFEST_INVALID"
-                  raise ::Dapp::Dimg::DockerRegistry::Error::ManifestInvalid.new(url, api_url, "#{err.response.status_line.strip}: #{err.response.reason_phrase.strip}: #{err.response.body.strip}")
-                end
-              end
-            end
+        def ruby2go_docker_registry_command(command:, **options)
+          (options[:options] ||= {}).merge!(host_docker_config_dir: dapp.class.host_docker_config_dir)
+          dapp.ruby2go_docker_registry(command: command, **options).tap do |res|
+            raise Error::Registry, code: :ruby2go_docker_registry_command_failed_unexpected_error, data: { command: command, message: res["error"] } unless res["error"].nil?
+            break res['data']
           end
-
-          raise(::Dapp::Dimg::DockerRegistry::Error::Base,
-            code: :unknown_error,
-            data: { url: url,
-                    registry: api_url,
-                    message: "#{err.response.status_line.strip}: #{err.response.reason_phrase.strip}: #{err.response.body.strip}" }
-          )
-        end
-
-        def api_url(*uri)
-          File.join(hostname_url, API_VERSION, '/', *uri)
-        end
-
-        def default_api_options
-          { expects: [200] }
-        end
-
-        def user_not_authorized!
-          raise ::Dapp::Dimg::DockerRegistry::Error::Base, code: :user_not_authorized, data: { registry: api_url }
         end
       end
     end # DockerRegistry

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

@@ -3,54 +3,60 @@ module Dapp
     module DockerRegistry
       class Dimg < Base
         def dimgstages_tags
-          tags.select { |tag| tag.start_with?('dimgstage') }
+          tags_wrapper do
+            ruby2go_docker_registry_command(command: :dimgstage_tags, options: { reference: tag_reference })
+          end
         end
 
         def dimg_tags(dimg_name)
-          with_repo_suffix(dimg_name.to_s) { tags }
+          tags_wrapper do
+            with_dimg_repository(dimg_name.to_s) do
+              ruby2go_docker_registry_command(command: :dimg_tags, options: { reference: tag_reference })
+            end
+          end
         end
 
         def nameless_dimg_tags
-          tags.select { |tag| !tag.start_with?('dimgstage') }
+          tags_wrapper do
+            ruby2go_docker_registry_command(command: :dimg_tags, options: { reference: tag_reference })
+          end
         end
 
-        def tags
-          super
-        rescue ::Dapp::Dimg::DockerRegistry::Error::Base => e
-          raise unless e.net_status[:code] == :page_not_found
+        def tags_wrapper
+          yield || []
+        rescue Error::Registry => e
+          raise unless e.net_status[:data][:message].include?("NAME_UNKNOWN")
           []
         end
 
-        def image_id(tag, extra_repo_suffix = nil)
-          with_repo_suffix(extra_repo_suffix.to_s) { super(tag) }
+        def image_id(tag, dimg_repository = nil)
+          with_dimg_repository(dimg_repository.to_s) { super(tag) }
         end
 
-        def image_parent_id(tag, extra_repo_suffix = nil)
-          with_repo_suffix(extra_repo_suffix.to_s) { super(tag) }
+        def image_parent_id(tag, dimg_repository = nil)
+          with_dimg_repository(dimg_repository.to_s) { super(tag) }
         end
 
-        def image_labels(tag, extra_repo_suffix = nil)
-          with_repo_suffix(extra_repo_suffix.to_s) { super(tag) }
+        def image_config(tag, dimg_repository = nil)
+          with_dimg_repository(dimg_repository.to_s) { super(tag) }
         end
 
-        def image_delete(tag, extra_repo_suffix = nil)
-          with_repo_suffix(extra_repo_suffix.to_s) { super(tag) }
+        def image_delete(tag, dimg_repository = nil)
+          with_dimg_repository(dimg_repository.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
+        def image_digest(tag, dimg_repository = nil)
+          with_dimg_repository(dimg_repository.to_s) { super(tag) }
         end
 
         protected
 
-        def with_repo_suffix(extra_repo_suffix)
-          old_repo_suffix = repo_suffix
-          @repo_suffix = File.join(repo_suffix, extra_repo_suffix)
+        def with_dimg_repository(dimg_repository)
+          old_repository = repository
+          @repository    = File.join(old_repository, dimg_repository)
           yield
         ensure
-          @repo_suffix = old_repo_suffix
+          @repository = old_repository
         end
       end
     end # DockerRegistry

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

@@ -85,7 +85,7 @@ module Dapp
             docker_image_id = TEMPLATE_EMPTY_VALUE
             unless fake || without_registry
               begin
-                dimg_labels = dapp.dimg_registry(repo).image_labels(docker_tag, dimg.name)
+                dimg_labels = dapp.dimg_registry(repo).image_config(docker_tag, dimg.name)["config"]["Labels"]
                 docker_image_id = dapp.dimg_registry(repo).image_id(docker_tag, dimg.name)
               rescue ::Dapp::Dimg::Error::Registry => err
                 unless disable_warnings

data/lib/dapp/kube/kubernetes/manager/deployment.rb

@@ -50,11 +50,12 @@ module Dapp
 
               dapp.log_step("[#{Time.now}] Poll deployment '#{d.name}' status")
               dapp.with_log_indent do
-                dapp.log_info("Replicas: #{_field_value_for_log(d.status['replicas'])}")
-                dapp.log_info("Updated replicas: #{_field_value_for_log(d.status['updatedReplicas'])}")
-                dapp.log_info("Available replicas: #{_field_value_for_log(d.status['availableReplicas'])}")
-                dapp.log_info("Unavailable replicas: #{_field_value_for_log(d.status['unavailableReplicas'])}")
+                dapp.log_info("Target replicas: #{_field_value_for_log(d.replicas)}")
+                dapp.log_info("Updated replicas: #{_field_value_for_log(d.status['updatedReplicas'])} / #{_field_value_for_log(d.replicas)}")
+                dapp.log_info("Available replicas: #{_field_value_for_log(d.status['availableReplicas'])} / #{_field_value_for_log(d.replicas)}")
                 dapp.log_info("Ready replicas: #{_field_value_for_log(d.status['readyReplicas'])} / #{_field_value_for_log(d.replicas)}")
+                dapp.log_info("Old deployment.kubernetes.io/revision: #{_field_value_for_log(@revision_before_deploy)}")
+                dapp.log_info("Current deployment.kubernetes.io/revision: #{_field_value_for_log(d_revision)}")
               end
 
               rs = nil
@@ -83,16 +84,6 @@ module Dapp
               end
 
               if rs
-                dapp.with_log_indent do
-                  dapp.log_step("Current ReplicaSet '#{rs.name}' status")
-                  dapp.with_log_indent do
-                    dapp.log_info("Replicas: #{_field_value_for_log(rs.status['replicas'])}")
-                    dapp.log_info("Fully labeled replicas: #{_field_value_for_log(rs.status['fullyLabeledReplicas'])}")
-                    dapp.log_info("Available replicas: #{_field_value_for_log(rs.status['availableReplicas'])}")
-                    dapp.log_info("Ready replicas: #{_field_value_for_log(rs.status['readyReplicas'])} / #{_field_value_for_log(d.replicas)}")
-                  end
-                end
-
                 # Pod'ы связанные с активным ReplicaSet
                 rs_pods = dapp.kubernetes.pod_list['items']
                   .map {|spec| Kubernetes::Client::Resource::Pod.new(spec)}
@@ -177,14 +168,19 @@ module Dapp
                 end # with_log_indent
               end
 
-              # break only when rs is not nil
-
-              if d_revision && d.replicas && d.replicas == 0
-                break
-              end
-
-              if d_revision && d.replicas && rs
-                break if is_deployment_ready(d) && is_replicaset_ready(d, rs)
+              if d_revision && d.replicas
+                if d.replicas == 0
+                  break
+                else
+                  break if begin
+                    d.status['updatedReplicas'] &&
+                      d.status['availableReplicas'] &&
+                        d.status['readyReplicas'] &&
+                          (d.status['updatedReplicas'] >= d.replicas) &&
+                            (d.status['availableReplicas'] >= d.replicas) &&
+                              (d.status['readyReplicas'] >= d.replicas)
+                  end
+                end
               end
 
               sleep 5
@@ -193,14 +189,6 @@ module Dapp
           end
         end
 
-        def is_deployment_ready(d)
-          d.status.key?("readyReplicas") && d.status["readyReplicas"] >= d.replicas
-        end
-
-        def is_replicaset_ready(d, rs)
-          rs.status.key?("readyReplicas") && rs.status["readyReplicas"] >= d.replicas
-        end
-
         private
 
         def _field_value_for_log(value)

data/lib/dapp/version.rb

@@ -1,4 +1,4 @@
 module Dapp
-  VERSION = "0.34.7"
+  VERSION = "0.35.0"
   BUILD_CACHE_VERSION = 31
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dapp
 version: !ruby/object:Gem::Version
-  version: 0.34.7
+  version: 0.35.0
 platform: ruby
 authors:
 - Dmitry Stolyarov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-08 00:00:00.000000000 Z
+date: 2018-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mixlib-shellout
@@ -627,11 +627,7 @@ files:
 - lib/dapp/dimg/dimg/stages.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/docker_registry/error.rb
 - lib/dapp/dimg/error/build.rb
 - lib/dapp/dimg/error/chef.rb
 - lib/dapp/dimg/error/default.rb
@@ -744,7 +740,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 2.5.0
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Build docker packaged apps using chef or shell

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

@@ -1,69 +0,0 @@
-module Dapp
-  module Dimg
-    module DockerRegistry
-      class Base
-        module Authorization
-          def authorization_options(url, method:)
-            (@authorization_options ||= {})[[@repo_suffix, method]] ||= begin
-              case authenticate_header = raw_request(url, method: method).headers['Www-Authenticate']
-                when /Bearer/ then { headers: { Authorization: "Bearer #{authorization_token(authenticate_header)}" } }
-                when /Basic/ then { headers: { Authorization: "Basic #{authorization_auth}" } }
-                when nil then {}
-                else raise ::Dapp::Dimg::DockerRegistry::Error::Base, code: :authenticate_type_not_supported, data: { registry: api_url }
-              end
-            end
-          end
-
-          def authorization_token(authenticate_header)
-            options = parse_authenticate_header(authenticate_header)
-            realm = options.delete(:realm)
-            begin
-              response = raw_request(realm, headers: { Authorization: "Basic #{authorization_auth}" }, query: options, expects: [200])
-            rescue ::Dapp::Dimg::DockerRegistry::Error::Base
-              raise unless (response = raw_request(realm, query: options)).status == 200
-            end
-            JSON.load(response.body)['token']
-          end
-
-          def parse_authenticate_header(header)
-            [:realm, :service, :scope].map do |option|
-              /#{option}="([[^"].]*)/ =~ header
-              next unless Regexp.last_match(1)
-              [option, Regexp.last_match(1)]
-            end.compact.to_h
-          end
-
-          def authorization_auth
-            @authorization_auth ||= begin
-              if ::Dapp::Dapp.options_with_docker_credentials?
-                Base64.strict_encode64(::Dapp::Dapp.docker_credentials.join(':'))
-              else
-                auths = auths_section_from_docker_config
-                r = repo
-                loop do
-                  break unless r.include?('/') && !auths.keys.any? { |auth| auth.start_with?(r) }
-                  r = chomp_name(r)
-                end
-                credential = (auths[r] || auths.find { |repo, _| repo == r })
-                user_not_authorized! if credential.nil?
-                credential['auth']
-              end
-            end
-          end
-
-          def auths_section_from_docker_config
-            file = Pathname(File.join(::Dapp::Dapp.host_docker_config_dir, 'config.json'))
-            user_not_authorized! unless file.exist?
-            JSON.load(file.read)['auths'].tap { |auths| user_not_authorized! if auths.nil? }
-          end
-
-          private
-
-          def chomp_name(r)
-            r.split('/')[0..-2].join('/')
-          end
-        end
-      end # Base
-    end # DockerRegistry
-  end # Dimg
-end # Dapp

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

@@ -1,34 +0,0 @@
-module Dapp
-  module Dimg
-    module DockerRegistry
-      class Base
-        module Request
-          def self.included(base)
-            base.extend(self)
-          end
-
-          def request(url, **options)
-            raw_request(url, options.in_depth_merge(authorization_options(url, method: options[:method] || :get)))
-          end
-
-          def raw_request(url, **options)
-            Excon.new(url).request(default_request_options.in_depth_merge(options))
-          end
-
-          def url_available?(url)
-            raw_request(url, expects: [200])
-            true
-          rescue Excon::Error
-            false
-          end
-
-          protected
-
-          def default_request_options
-            { method: :get, omit_default_port: true }
-          end
-        end
-      end # Base
-    end # DockerRegistry
-  end # Dimg
-end # Dapp

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

@@ -1,18 +0,0 @@
-module Dapp
-  module Dimg
-    module DockerRegistry
-      class Default < Dimg
-        DEFAULT_HOSTNAME_URL = 'https://registry.hub.docker.com'.freeze
-
-        def initialize(repo, repo_suffix)
-          super(repo, DEFAULT_HOSTNAME_URL, repo_suffix)
-        end
-
-        def repo_suffix=(val)
-          val = "library/#{val}" if val.split('/').one?
-          super(val)
-        end
-      end
-    end
-  end # Dimg
-end # Dapp

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

@@ -1,25 +0,0 @@
-module Dapp
-  module Dimg
-    module DockerRegistry
-      module Error
-        class Base < ::Dapp::Dimg::Error::Registry
-          def initialize(**net_status)
-            super(**net_status, context: :registry)
-          end
-        end
-
-        class ManifestInvalid < Base
-          def initialize(url, registry, response_body)
-            super(code: :manifest_invalid, data: {url: url, registry: registry, response_body: response_body})
-          end
-        end
-
-        class ImageNotFound < Base
-          def initialize(url, registry)
-            super(code: :page_not_found, data: { url: url, registry: registry })
-          end
-        end
-      end # Error
-    end # DockerRegistry
-  end # Dimg
-end # Dapp