dapp 0.22.5 → 0.22.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 72f96ae3e42af1393dec73f054dee4da337047b3
-  data.tar.gz: 8005f3e23ca213706eac5961008d720c968c1093
+  metadata.gz: 657b2271dc5a641fcd90ed720470a81ce478f73a
+  data.tar.gz: 5b4201a16c7da7be4cdddc0b9b3a2a697c7e59b9
 SHA512:
-  metadata.gz: 28640a023ce81573843dfff84c7752442a3128cd567f3345de765e4743c20b1dc2c7f071aa92d43f2628dce5c3c1c9acf8de7ddb38d7e3eeeeea685ffc2534e1
-  data.tar.gz: 9ec9801ea482897662c820dc92a2da5593491ee404699d5100cc8ab4fe262465e68bcba17c2fb0b8a6db278bdc3d23a91789b1e5b4f0cc1173c861e2c16dc622
+  metadata.gz: 9ddad23ac4121cec7218dbaef4b2353710eef0d62bbe618cd07a25e89f1ea21b9b49e89e7282198f8a3d767cd8f85291fc854e38161c3bc05683443530ba09b4
+  data.tar.gz: bdc290374d797d1d5632226fa20e168c2f14350f988e60bc53c6e7966c9ff9795bc03bc863974cdff8136f24319ef5ea06223aace8f8b59f3e3067babbaa0093

data/config/en/net_status.yml

@@ -108,11 +108,11 @@ 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:
-      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!'
+      registry_not_available: 'Registry `%{registry}`: not available!'
     rugged:
       git_repository_reference_error: "Git repo `%{name}`: %{message}!"
       rugged_remote_error: "Remote git repo `%{url}`: `%{message}`!"

data/lib/dapp.rb

@@ -24,6 +24,7 @@ require 'openssl'
 require 'etc'
 require 'zlib'
 require 'slugify'
+require 'base64'
 
 require 'dapp/version'
 require 'dapp/core_ext/hash'

data/lib/dapp/cli/command/base.rb

@@ -7,14 +7,6 @@ module Dapp
                description: 'Change to directory',
                on: :head
 
-        %w(run_dir build_dir deploy_dir).tap do |dirs|
-          dirs.each do |dir|
-            option dir.to_sym,
-                  long: "--#{dir.gsub("_", "-")} PATH",
-                  description: "Directory where reside: build cache, lock files for concurrent dapp operations (DIR/.dapp_build by default). Alias for #{(dirs - [dir]).map{|d| "--" + d.gsub("_", "-")}.join(", ")}."
-          end
-        end
-
         option :name,
                long: "--name NAME",
                description: "Use custom dapp name. Chaging default name will cause full cache rebuild. By default dapp name is the last element of remote.origin.url from project git, or it is the name of the directory where Dappfile resides."
@@ -64,12 +56,12 @@ module Dapp
           super()
         end
 
-        def run_dapp_command(run_method, options: {}, log_running_time: true)
+        def run_dapp_command(run_method, options: {}, log_running_time: true, try_host_docker_login: false)
           dapp = ::Dapp::Dapp.new(options: options)
 
           log_dapp_running_time(dapp, ignore: !log_running_time) do
             begin
-              before_dapp_run_command(dapp)
+              dapp.try_host_docker_login if try_host_docker_login
 
               if block_given?
                 yield dapp
@@ -97,11 +89,6 @@ module Dapp
           raise
         end
 
-        def before_dapp_run_command(dapp, &blk)
-          yield if block_given?
-          dapp.try_host_docker_login
-        end
-
         def cli_options(**kwargs)
           dirs = [config[:build_dir], config[:run_dir], config[:deploy_dir]]
           if dirs.compact.size > 1

data/lib/dapp/dapp.rb

@@ -91,7 +91,8 @@ module Dapp
         if option_build_dir
           Pathname.new(option_build_dir)
         else
-          path('.dapp_build')
+          dir = File.join(self.class.home_dir, "builds", self.name)
+          Pathname.new(dir)
         end.expand_path.tap(&:mkpath)
       end
       make_path(@build_path, *path)
@@ -127,20 +128,21 @@ module Dapp
     end
 
     def try_host_docker_login
-      return if options[:without_registry]
       return unless option_repo
 
       validate_repo_name!(option_repo)
 
-      login = proc {|u, p| shellout!("#{host_docker} login -u '#{u}' -p '#{p}' '#{option_repo}'")}
-      if options.key?(:registry_username) && options.key?(:registry_password)
-        login.call(options[:registry_username], options[:registry_password])
-      elsif ENV.key?('CI_JOB_TOKEN')
-        login.call('gitlab-ci-token', ENV['CI_JOB_TOKEN'])
+      if self.class.options_with_docker_credentials?
+        username, password = self.class.docker_credentials
+        shellout!("#{host_docker} login -u '#{username}' -p '#{password}' '#{option_repo}'")
       end
     end
 
     class << self
+      def home_dir
+        File.join(Dir.home, ".dapp")
+      end
+
       def options
         @options ||= {}
       end
@@ -182,6 +184,14 @@ module Dapp
         (options.key?(:registry_username) && options.key?(:registry_password)) || ENV.key?('CI_JOB_TOKEN')
       end
 
+      def docker_credentials
+        if options.key?(:registry_username) && options.key?(:registry_password)
+          [options[:registry_username], options[:registry_password]]
+        elsif ENV.key?('CI_JOB_TOKEN')
+          ['gitlab-ci-token', ENV['CI_JOB_TOKEN']]
+        end
+      end
+
       def host_docker_tmp_config_dir
         @host_docker_tmp_config_dir ||= Dir.mktmpdir('dapp-', tmp_base_dir)
       end

data/lib/dapp/dapp/deps/base.rb

@@ -12,7 +12,7 @@ module Dapp
           @base_container ||= begin
             is_container_exist = proc{shellout("#{host_docker} inspect #{base_container_name}").exitstatus.zero?}
             if !is_container_exist.call
-              lock("dappdeps.container.#{base_container_name}", default_timeout: 120, type: :global) do
+              lock("dappdeps.container.#{base_container_name}", default_timeout: 120) do
                 if !is_container_exist.call
                   log_secondary_process(t(code: 'process.base_container_creating', data: {name: base_container_name}), short: true) do
                     shellout!(

data/lib/dapp/dapp/deps/gitartifact.rb

@@ -12,7 +12,7 @@ module Dapp
           @gitartifact_container ||= begin
             is_container_exist = proc{shellout("#{host_docker} inspect #{gitartifact_container_name}").exitstatus.zero?}
             if !is_container_exist.call
-              lock("dappdeps.container.#{gitartifact_container_name}", default_timeout: 120, type: :global) do
+              lock("dappdeps.container.#{gitartifact_container_name}", default_timeout: 120) do
                 if !is_container_exist.call
                   log_secondary_process(t(code: 'process.gitartifact_container_creating', data: {name: gitartifact_container_name}), short: true) do
                     shellout!(

data/lib/dapp/dapp/deps/toolchain.rb

@@ -12,7 +12,7 @@ module Dapp
           @toolchain_container ||= begin
             is_container_exist = proc {shellout("#{host_docker} inspect #{toolchain_container_name}").exitstatus.zero?}
             if !is_container_exist.call
-              lock("dappdeps.container.#{toolchain_container_name}", default_timeout: 300, type: :global) do
+              lock("dappdeps.container.#{toolchain_container_name}", default_timeout: 300) do
                 if !is_container_exist.call
                   log_secondary_process(t(code: 'process.toolchain_container_creating', data: {name: toolchain_container_name}), short: true) do
                     shellout!(

data/lib/dapp/dapp/lock.rb

@@ -1,31 +1,21 @@
 module Dapp
   class Dapp
     module Lock
-      def lock_path(type)
-        case type
-        when :dapp
-          build_path.join('locks')
-        when :global
-          Pathname.new("/tmp/dapp.global.locks").tap do |p|
-            FileUtils.mkdir_p p.to_s
-          end
-        else
-          raise
-        end
+      def locks_dir
+        File.join(self.class.home_dir, "locks")
       end
 
-      def _lock(name, type)
+      def _lock(name)
         @_locks ||= {}
-        @_locks[type] ||= {}
-        @_locks[type][name] ||= ::Dapp::Dimg::Lock::File.new(lock_path(type), name)
+        @_locks[name] ||= ::Dapp::Dimg::Lock::File.new(locks_dir, name)
       end
 
-      def lock(name, *_args, default_timeout: 300, type: :dapp, **kwargs, &blk)
+      def lock(name, *_args, default_timeout: 300, **kwargs, &blk)
         if dry_run?
           yield if block_given?
         else
           timeout = options[:lock_timeout] || default_timeout
-          _lock(name, type).synchronize(
+          _lock(name).synchronize(
             timeout: timeout,
             on_wait: proc do |&do_wait|
               log_secondary_process(

data/lib/dapp/dapp/logging/base.rb

@@ -84,6 +84,10 @@ module Dapp
         end
 
         def log_time
+          self.class.log_time
+        end
+
+        def self.log_time
           "#{DateTime.now.strftime('%Y-%m-%dT%T%z')} "
         end
 
@@ -117,12 +121,6 @@ module Dapp
           end
         end
 
-        class << self
-          def included(base)
-            base.extend(self)
-          end
-        end
-
         def service_stream
           @@service_stream ||= begin
             fd = IO.sysopen("/tmp/dapp-service.log", "a")

data/lib/dapp/dapp/slug.rb

@@ -3,7 +3,7 @@ module Dapp
     module Slug
       def consistent_uniq_slugify(s)
         if should_be_slugged?(s)
-          consistent_uniq_slug_reg =~ s.slugify.squeeze('--')
+          consistent_uniq_slug_reg =~ s.gsub("/", "-").slugify.squeeze('--')
           [].tap do |slug|
             slug << Regexp.last_match(1) unless Regexp.last_match(1).nil?
             slug << MurmurHash3::V32.str_hexdigest(s)

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

@@ -64,7 +64,7 @@ module Dapp
         @chefdk_container ||= begin
           is_container_exist = proc{dimg.dapp.shellout("#{dimg.dapp.host_docker} inspect #{chefdk_container_name}").exitstatus.zero?}
           if !is_container_exist.call
-            dimg.dapp.lock("dappdeps.container.#{chefdk_container_name}", default_timeout: 120, type: :global) do
+            dimg.dapp.lock("dappdeps.container.#{chefdk_container_name}", default_timeout: 120) do
               if !is_container_exist.call
                 dimg.dapp.log_secondary_process(dimg.dapp.t(code: 'process.chefdk_container_creating', data: {name: chefdk_container_name}), short: true) do
                   dimg.dapp.shellout!(

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

@@ -1,6 +1,10 @@
 module Dapp::Dimg::CLI
   module Command
     class Base < ::Dapp::CLI::Command::Base
+      option :build_dir,
+             long: "--build-dir PATH",
+             description: "Directory where build cache stored ($HOME/.dapp/builds/<dapp name> by default)."
+
       def run(argv = ARGV)
         self.class.parse_options(self, argv)
         run_dapp_command(run_method, options: cli_options(dimgs_patterns: cli_arguments))

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

@@ -59,7 +59,9 @@ 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))
+          run_dapp_command(run_method,
+                           options: cli_options(dimgs_patterns: cli_arguments, repo: repo),
+                           try_host_docker_login: true)
         end
       end
     end

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

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

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

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

data/lib/dapp/dimg/config/directive/dimg/instance_methods.rb

@@ -24,7 +24,7 @@ module Dapp
 
             def artifact(&blk)
               pass_to(ArtifactGroup.new(dapp: dapp), :clone_to_artifact).tap do |artifact_group|
-                _artifact_groups << directive_eval(artifact_group, &blk)
+                _context_artifact_groups << directive_eval(artifact_group, &blk)
               end
             end
 
@@ -73,8 +73,12 @@ module Dapp
               @_artifact_groups ||= []
             end
 
+            def _context_artifact_groups
+              @_context_artifact_groups ||= []
+            end
+
             def _artifact
-              _artifact_groups.map(&:_export).flatten
+              [_artifact_groups, _context_artifact_groups].flatten.map(&:_export).flatten
             end
 
             [:before, :after].each do |order|

data/lib/dapp/dimg/config/directive/dimg_group.rb

@@ -39,11 +39,20 @@ module Dapp
           protected
 
           def before_dimg_eval(dimg)
-            pass_to(dimg)
+            before_eval_base(dimg)
           end
 
           def before_dimg_group_eval(dimg_group)
-            pass_to(dimg_group)
+            before_eval_base(dimg_group)
+          end
+
+          def before_eval_base(obj)
+            pass_to(obj)
+            pass_context_artifact_groups_to(obj)
+          end
+
+          def pass_context_artifact_groups_to(obj)
+            obj.instance_variable_set(:@_artifact_groups, [obj._artifact_groups, clone_variable(_context_artifact_groups)].flatten)
           end
 
           def check_dimg_directive_order(directive)

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

@@ -95,10 +95,8 @@ module Dapp
 
           def check_user_containers!(images_ids)
             return if images_ids.empty?
-            log_step_with_indent(:'check user containers') do
-              run_command(%(#{host_docker} ps -a -q #{images_ids.uniq.map { |image_id| "--filter=ancestor=#{image_id}" }.join(' ')} --no-trunc)).tap do |res|
-                raise Error::Command, code: :user_containers_detected, data: { ids: res.stdout.strip } if res && !res.stdout.strip.empty? && !dry_run?
-              end
+            run_command(%(#{host_docker} ps -a -q #{images_ids.uniq.map { |image_id| "--filter=ancestor=#{image_id}" }.join(' ')} --no-trunc)).tap do |res|
+              raise Error::Command, code: :user_containers_detected, data: { ids: res.stdout.strip } if res && !res.stdout.strip.empty? && !dry_run?
             end
           end
 
@@ -150,6 +148,10 @@ module Dapp
             log_step_with_indent(:'proper cache', &blk)
           end
 
+          def log_proper_repo_cache(&blk)
+            log_step_with_indent(:'proper repo cache', &blk)
+          end
+
           def one_dimg!
             return if build_configs.one?
             raise Error::Command, code: :command_unexpected_dimgs_number, data: { dimgs_names: build_configs.map(&:_name).join(' ') }

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

@@ -21,9 +21,7 @@ module Dapp
             def proper_cache
               log_proper_cache do
                 lock("#{name}.images") do
-                  log_step_with_indent(name) do
-                    remove_project_images(dapp_project_images_ids.select { |image_id| !actual_cache_project_images_ids.include?(image_id) })
-                  end
+                  remove_project_images(dapp_project_images_ids.select { |image_id| !actual_cache_project_images_ids.include?(image_id) })
                 end
               end
             end
@@ -38,15 +36,15 @@ module Dapp
             end
 
             def stages_cleanup_by_repo
-              registry   = dimg_registry(option_repo)
-              repo_dimgs = repo_dimgs_images(registry)
+              log_proper_repo_cache do
+                lock("#{name}.images") do
+                  registry   = dimg_registry(option_repo)
+                  repo_dimgs = repo_detailed_dimgs_images(registry)
 
-              lock("#{name}.images") do
-                log_step_with_indent(name) do
                   dapp_project_dangling_images_flush
 
-                  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) }
+                  _, dimgstages = dapp_project_images.partition { |image| repo_dimgs.any? { |dimg| dimg[:id] == image[:id] } }
+                  repo_dimgs.each { |repo_dimg| except_dapp_project_image_with_parents(repo_dimg[:parent], dimgstages) }
 
                   # Удаление только образов старше 2ч
                   dimgstages.delete_if do |dimgstage|

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

@@ -8,37 +8,25 @@ module Dapp
 
             def repo_dimgs_images(registry)
               [].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
+                {}.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
 
             def repo_dimgstages_images(registry)
-              with_registry_wrapper do
-                tags_to_repo_images(registry, registry.dimgstages_tags)
-              end
+              tags_to_repo_images(registry, registry.dimgstages_tags)
             end
 
             def tags_to_repo_images(registry, tags, dimg_name = nil)
               tags.map { |tag| repo_image_format(registry, tag, dimg_name) }.compact
             end
 
-            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 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 } })

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

@@ -6,11 +6,9 @@ module Dapp
           module FlushLocal
             def stages_flush_local
               lock("#{name}.images") do
-                log_step_with_indent(name) do
-                  dapp_project_containers_flush
-                  dapp_project_dangling_images_flush
-                  remove_project_images(dapp_project_images_ids)
-                end
+                dapp_project_containers_flush
+                dapp_project_dangling_images_flush
+                remove_project_images(dapp_project_images_ids)
               end
             end
           end

data/lib/dapp/dimg/docker_registry.rb

@@ -11,8 +11,10 @@ module Dapp
             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 Error::Registry, code: :registry_not_available, data: { registry: repo }
+        else
+          Default.new(repo, expected_repo_suffix)
         end
-        Default.new(repo, File.join(*[expected_hostname, expected_repo_suffix].compact))
       end
 
       def self.repo_name_format

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

@@ -19,9 +19,6 @@ module Dapp
 
         def 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
         end
 
         def image_id(tag)

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

@@ -34,15 +34,19 @@ module Dapp
           end
 
           def authorization_auth
-            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)
+            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
-            credential = (auths[r] || auths.find { |repo, _| repo == r })
-            user_not_authorized! if credential.nil?
-            credential['auth']
           end
 
           def auths_section_from_docker_config

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

@@ -8,15 +8,19 @@ module Dapp
 
         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
+          super
+        rescue Error::Registry => e
+          raise unless e.net_status[:code] == :page_not_found
+          []
+        end
+
         def image_id(tag, extra_repo_suffix = nil)
           with_repo_suffix(extra_repo_suffix.to_s) { super(tag) }
         end

data/lib/dapp/dimg/lock/file.rb

@@ -10,18 +10,18 @@ module Dapp
           end
         end # << self
 
-        attr_reader :lock_path
+        attr_reader :locks_path
 
-        def initialize(lock_path, name)
+        def initialize(locks_path, name)
           super(name)
 
-          @lock_path = Pathname.new(lock_path).tap(&:mkpath)
+          @locks_path = Pathname.new(locks_path).tap(&:mkpath)
         end
 
         protected
 
         def lock_file_path
-          lock_path.join(MurmurHash3::V32.str_hexdigest(name))
+          locks_path.join(MurmurHash3::V32.str_hexdigest(name))
         end
 
         def _do_lock(timeout, on_wait, readonly)

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

@@ -83,26 +83,22 @@ BANNER
 
       def run(argv = ARGV)
         self.class.parse_options(self, argv)
-        run_dapp_command(run_method, options: cli_options)
-      end
 
-      def before_dapp_run_command(dapp, &blk)
-        super(dapp) do
-          yield if block_given?
+        options = cli_options
+        options[:tag] = [*options.delete(:tag), *options.delete(:image_version)]
 
-          # Опция repo определяется в данном хуке, чтобы установить
-          # значение по умолчанию из объекта dapp: dapp.name
+        run_dapp_command(nil, options: options) do |dapp|
           repo = if not cli_arguments[0].nil?
             self.class.required_argument(self, 'repo')
           else
             dapp.name
           end
+
           dapp.options[:repo] = repo
 
-          dapp.options[:tag] = [*dapp.options.delete(:tag), *dapp.options.delete(:image_version)]
-        end # super
+          dapp.public_send(run_method)
+        end
       end
-
     end
   end
 end

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

@@ -56,24 +56,19 @@ BANNER
 
       def run(argv = ARGV)
         self.class.parse_options(self, argv)
-        run_dapp_command(run_method, options: cli_options, log_running_time: false)
-      end
-
-      def before_dapp_run_command(dapp, &blk)
-        super(dapp) do
-          yield if block_given?
 
-          # Опция repo определяется в данном хуке, чтобы установить
-          # значение по умолчанию из объекта dapp: dapp.name
+        run_dapp_command(nil, options: cli_options, log_running_time: false) do |dapp|
           repo = if not cli_arguments[0].nil?
             self.class.required_argument(self, 'repo')
           else
             dapp.name
           end
+
           dapp.options[:repo] = repo
-        end # super
-      end
 
+          dapp.public_send(run_method)
+        end
+      end
     end
   end
 end

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

@@ -65,24 +65,18 @@ BANNER
 
       def run(argv = ARGV)
         self.class.parse_options(self, argv)
-        run_dapp_command(run_method, options: cli_options, log_running_time: false)
-      end
-
-      def before_dapp_run_command(dapp, &blk)
-        super(dapp) do
-          yield if block_given?
-
-          # Опция repo определяется в данном хуке, чтобы установить
-          # значение по умолчанию из объекта dapp: dapp.name
+        run_dapp_command(nil, options: cli_options, log_running_time: false) do |dapp|
           repo = if not cli_arguments[0].nil?
             self.class.required_argument(self, 'repo')
           else
             dapp.name
           end
+
           dapp.options[:repo] = repo
-        end # super
-      end
 
+          dapp.public_send(run_method)
+        end
+      end
     end
   end
 end

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

@@ -31,7 +31,9 @@ module Dapp
             kube_check_helm_chart!
 
             repo = option_repo
-            docker_tag = consistent_uniq_slugify(options[:docker_tag])
+
+            docker_tag = options[:docker_tag]
+            docker_tag = consistent_uniq_slugify(docker_tag) if docker_tag
 
             with_kube_tmp_lint_chart_dir do
               kube_copy_chart

data/lib/dapp/version.rb

@@ -1,4 +1,4 @@
 module Dapp
-  VERSION = '0.22.5'.freeze
+  VERSION = '0.22.6'.freeze
   BUILD_CACHE_VERSION = 25
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dapp
 version: !ruby/object:Gem::Version
-  version: 0.22.5
+  version: 0.22.6
 platform: ruby
 authors:
 - Dmitry Stolyarov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-13 00:00:00.000000000 Z
+date: 2017-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mixlib-shellout