dapp 0.10.2 → 0.36.24

data/lib/dapp/dimg/config/dimg/validation.rb

@@ -1,126 +0,0 @@
-module Dapp
-  module Dimg
-    module Config
-      class Dimg < Base
-        module Validation
-          def validate!
-            directives_validate!
-            validate_scratch!
-            validate_artifacts!
-            validate_artifacts_artifacts!
-          end
-
-          protected
-
-          def validate_scratch!
-            if _docker._from.nil?
-              validate_scratch_directives!
-              validate_scratch_artifacts!
-            else
-              raise Error::Config, code: :stage_artifact_not_associated unless _import_artifact.empty?
-            end
-          end
-
-          def directives_validate!
-            passed_directives.each do |v|
-              next if (value = instance_variable_get(v)).nil?
-              Array(value).each do |elm|
-                elm.validate! if elm.respond_to?(:validate!)
-              end
-            end
-          end
-
-          def validate_scratch_directives!
-            directives = [[:_shell, :shell], [:_chef, :chef], [:_git_artifact, :git],
-                          [:_tmp_dir_mount, :mount], [:_build_dir_mount, :mount]]
-            directives.each do |name, user_name|
-              raise Error::Config,
-                    code: :scratch_unsupported_directive,
-                    data: { directive: user_name } unless public_send(name).empty?
-            end
-
-            docker_directives = [:_expose, :_env, :_cmd, :_onbuild, :_workdir, :_user, :_entrypoint]
-            docker_directives.each do |directive|
-              value = _docker.public_send(directive)
-              raise Error::Config,
-                    code: :scratch_unsupported_directive,
-                    data: { directive: "docker.#{directive}" } unless value.nil? || value.empty?
-            end
-          end
-
-          def validate_scratch_artifacts!
-            raise Error::Config, code: :scratch_artifact_associated unless _associated_artifacts.empty?
-            raise Error::Config, code: :scratch_artifact_required if _import_artifact.empty?
-            _import_artifact.each do |artifact|
-              raise Error::Config, code: :scratch_artifact_docker_from if artifact._config._docker._from.nil?
-            end
-          end
-
-          def validate_artifacts_artifacts!
-            _artifact.each { |artifact_dimg| artifact_dimg._config.validate! }
-          end
-
-          def validate_artifacts!
-            artifacts = validate_artifact_format(validated_artifacts)
-            loop do
-              break if artifacts.empty?
-              verifiable_artifact = artifacts.shift
-              artifacts.select { |a| a[:to] == verifiable_artifact[:to] }.each do |artifact|
-                next if verifiable_artifact[:index] == artifact[:index]
-                validate_artifact!(verifiable_artifact, artifact)
-                validate_artifact!(artifact, verifiable_artifact)
-              end
-            end
-          end
-
-          def validate_artifact_format(artifacts)
-            artifacts.map do |a|
-              path_format = proc { |path| File.expand_path(File.join('/', path, '/'))[1..-1] }
-
-              path_format.call(a._to) =~ %r{^([^\/]*)\/?(.*)$}
-              to = Regexp.last_match(1)
-              include_paths = a._include_paths.dup
-              include_paths << Regexp.last_match(2) unless Regexp.last_match(2).empty?
-              exclude_paths = a._exclude_paths.dup
-
-              {
-                index: artifacts.index(a),
-                to: to,
-                include_paths: include_paths.map(&path_format),
-                exclude_paths: exclude_paths.map(&path_format)
-              }
-            end
-          end
-
-          def validate_artifact!(verifiable_artifact, artifact)
-            verifiable_artifact[:include_paths].each do |verifiable_path|
-              potential_conflicts = artifact[:include_paths].select { |path| path.start_with?(verifiable_path) }
-              validate_artifact_path!(verifiable_artifact, potential_conflicts)
-            end.empty? && verifiable_artifact[:exclude_paths].empty? && raise(Error::Config, code: :artifact_conflict)
-            validate_artifact_path!(verifiable_artifact, artifact[:include_paths]) if verifiable_artifact[:include_paths].empty?
-          end
-
-          def validate_artifact_path!(verifiable_artifact, potential_conflicts)
-            potential_conflicts.all? do |path|
-              loop do
-                break if verifiable_artifact[:exclude_paths].include?(path) || ((path = File.dirname(path)) == '.')
-              end
-              verifiable_artifact[:exclude_paths].include?(path)
-            end.tap { |res| res || raise(Error::Config, code: :artifact_conflict) }
-          end
-
-          def _associated_artifacts
-            _artifact.select do |art|
-              !(art._before.nil? && art._after.nil?)
-            end
-          end
-
-          def validated_artifacts
-            _artifact + _git_artifact._local + _git_artifact._remote
-          end
-        end # Validation
-        # rubocop:enable Metrics/ModuleLength
-      end # Dimg
-    end # Config
-  end # Dimg
-end # Dapp

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

@@ -1,24 +0,0 @@
-module Dapp
-  module Dimg
-    module Config
-      class Dimg < Base
-        include Validation
-        include InstanceMethods
-
-        attr_reader :_name
-
-        def initialize(name, dapp:)
-          self._name = name
-          super(dapp: dapp)
-        end
-
-        def _name=(name)
-          return if name.nil?
-          reg = '^[[[:alnum:]]_.-]*$'
-          raise Error::Config, code: :dimg_name_incorrect, data: { name: name, reg: reg } unless name =~ /#{reg}/
-          @_name = name
-        end
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-module Dapp
-  module Dimg
-    module Config
-      class DimgGroup < DimgGroupBase
-        include Dimg::InstanceMethods
-
-        def chef(&blk)
-          check_dimg_directive_order(:chef)
-          super
-        end
-
-        def shell(&blk)
-          check_dimg_directive_order(:shell)
-          super
-        end
-
-        def docker(&blk)
-          check_dimg_directive_order(:docker)
-          super
-        end
-
-        def artifact(&blk)
-          check_dimg_group_directive_order(:artifact)
-          super
-        end
-
-        def git(url = nil, &blk)
-          check_dimg_directive_order(:git)
-          super
-        end
-
-        def mount(to, &blk)
-          check_dimg_directive_order(:mount)
-          super
-        end
-
-        protected
-
-        def before_dimg_eval(dimg)
-          pass_to_default(dimg)
-        end
-
-        def before_dimg_group_eval(dimg_group)
-          pass_to_default(dimg_group)
-        end
-
-        def check_dimg_directive_order(directive)
-          dapp.log_config_warning(desc: { code: 'wrong_using_base_directive',
-                                          data: { directive: directive },
-                                          context: 'warning' }) if _dimg.any? || _dimg_group.any? || _artifact.any?
-        end
-
-        def check_dimg_group_directive_order(directive)
-          dapp.log_config_warning(desc: { code: 'wrong_using_directive',
-                                          data: { directive: directive },
-                                          context: 'warning' }) if _dimg.any? || _dimg_group.any?
-        end
-      end
-    end
-  end
-end

data/lib/dapp/dimg/config/dimg_group_base.rb

@@ -1,54 +0,0 @@
-module Dapp
-  module Dimg
-    module Config
-      class DimgGroupBase < Base
-        attr_reader :_dimg_group
-
-        def initialize(dapp:)
-          @_dimg = []
-          @_dimg_group = []
-
-          super(dapp: dapp)
-        end
-
-        def dev_mode
-          @_dev_mode = true
-        end
-
-        def dimg(name = nil, &blk)
-          Config::Dimg.new(name, dapp: dapp).tap do |dimg|
-            before_dimg_eval(dimg)
-            dimg.instance_eval(&blk) if block_given?
-            @_dimg << dimg
-          end
-        end
-
-        def dimg_group(&blk)
-          Config::DimgGroup.new(dapp: dapp).tap do |dimg_group|
-            before_dimg_group_eval(dimg_group)
-            dimg_group.instance_eval(&blk) if block_given?
-            @_dimg_group << dimg_group
-          end
-        end
-
-        def _dimg
-          (@_dimg + @_dimg_group.map(&:_dimg)).flatten
-        end
-
-        protected
-
-        def before_dimg_eval(dimg)
-          pass_to_default(dimg)
-        end
-
-        def before_dimg_group_eval(dimg_group)
-          pass_to_default(dimg_group)
-        end
-
-        def pass_to_default(obj)
-          obj.instance_variable_set(:@_dev_mode, @_dev_mode)
-        end
-      end
-    end
-  end
-end

data/lib/dapp/dimg/config/dimg_group_main.rb

@@ -1,22 +0,0 @@
-module Dapp
-  module Dimg
-    module Config
-      class DimgGroupMain < DimgGroupBase
-        def dimg(name = nil, &blk)
-          with_dimg_validation { super(name, &blk) }
-        end
-
-        def dimg_group(&blk)
-          with_dimg_validation { super(&blk) }
-        end
-
-        protected
-
-        def with_dimg_validation
-          yield
-          raise Error::Config, code: :dimg_name_required if _dimg.any? { |dimg| dimg._name.nil? } && _dimg.size > 1
-        end
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Common)
-::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Run)
-::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Build)
-::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Bp)
-::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Push)
-::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Spush)
-::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Tag)
-::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::List)
-::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Stages::CleanupLocal)
-::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Stages::CleanupRepo)
-::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Stages::FlushLocal)
-::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Stages::FlushRepo)
-::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Stages::Push)
-::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Stages::Pull)
-::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Stages::Common)
-::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Cleanup)
-::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::Mrproper)
-::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::StageImage)
-::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::BuildContext::Import)
-::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::BuildContext::Export)
-::Dapp::Dapp.send(:include, Dapp::Dimg::Dapp::Command::BuildContext::Common)

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.cli_options[:tag]
-        end
-
-        def branch_tags
-          return [] unless dapp.cli_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.cli_options[:tag_commit]
-          commit = git_repo.latest_commit
-          [commit]
-        end
-
-        def build_tags
-          return [] unless dapp.cli_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.cli_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

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

@@ -1,63 +0,0 @@
-module Dapp
-  module Dimg
-    module DockerRegistry
-      class Base
-        module Authorization
-          def authorization_options(url)
-            @authorization_options ||= begin
-              case authenticate_header = raw_request(url).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 Error::Registry, 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 Error::Registry
-              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
-            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
-
-          def auths_section_from_docker_config
-            file = Pathname(File.join(Dir.home, '.docker', '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)))
-          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 < Base
-        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/error/base.rb

@@ -1,7 +0,0 @@
-module Dapp
-  module Dimg
-    module Error
-      class Base < ::Dapp::Error::Base; end
-    end
-  end
-end

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

@@ -1,7 +0,0 @@
-module Dapp
-  module Dimg
-    module Error
-      class Config < ::Dapp::Config::Error::Config; end
-    end
-  end
-end

data/lib/dapp/dimg/exception/introspect_image.rb

@@ -1,7 +0,0 @@
-module Dapp
-  module Dimg
-    module Exception
-      class IntrospectImage < Base; end
-    end
-  end
-end

data/lib/dapp/dimg/image/docker.rb

@@ -1,134 +0,0 @@
-module Dapp
-  module Dimg
-    module Image
-      class Docker
-        attr_reader :from
-        attr_reader :name
-        attr_reader :dapp
-
-        def self.image_by_name(name:, **kwargs)
-          (@images ||= {})[name] ||= new(name: name, **kwargs)
-        end
-
-        def initialize(name:, dapp:, from: nil)
-          @from = from
-          @name = name
-          @dapp = dapp
-        end
-
-        def id
-          cache[:id]
-        end
-
-        def untag!
-          raise Error::Build, code: :image_already_untagged, data: { name: name } unless tagged?
-          dapp.shellout!("docker rmi #{name}")
-          cache_reset
-        end
-
-        def push!
-          raise Error::Build, code: :image_not_exist, data: { name: name } unless tagged?
-          dapp.log_secondary_process(dapp.t(code: 'process.image_push', data: { name: name })) do
-            dapp.shellout!("docker push #{name}", log_verbose: true)
-          end
-        end
-
-        def pull!
-          return if tagged?
-          dapp.log_secondary_process(dapp.t(code: 'process.image_pull', data: { name: name })) do
-            dapp.shellout!("docker pull #{name}", log_verbose: true)
-          end
-          cache_reset
-        end
-
-        def tagged?
-          !!id
-        end
-
-        def created_at
-          raise Error::Build, code: :image_not_exist, data: { name: name } unless tagged?
-          cache[:created_at]
-        end
-
-        def size
-          raise Error::Build, code: :image_not_exist, data: { name: name } unless tagged?
-          cache[:size]
-        end
-
-        def self.image_config_option(image_id:, option:)
-          output = ::Dapp::Dapp.shellout!("docker inspect --format='{{json .Config.#{option.to_s.capitalize}}}' #{image_id}").stdout.strip
-          output == 'null' ? [] : JSON.parse(output)
-        end
-
-        def cache_reset
-          self.class.cache_reset(name)
-        end
-
-        protected
-
-        def cache
-          self.class.cache[name.to_s] || {}
-        end
-
-        class << self
-          def image_name_format
-            separator = '[_.]|__|[-]*'
-            tag = "[[:alnum:]][[[:alnum:]]#{separator}]{0,127}"
-            "#{DockerRegistry.repo_name_format}(:(?<tag>#{tag}))?"
-          end
-
-          def image_name?(name)
-            !(/^#{image_name_format}$/ =~ name).nil?
-          end
-
-          def tag!(id:, tag:)
-            ::Dapp::Dapp.shellout!("docker tag #{id} #{tag}")
-            cache_reset
-          end
-
-          def save!(image_or_images, file_path)
-            images = Array(image_or_images).join(' ')
-            ::Dapp::Dapp.shellout!("docker save -o #{file_path} #{images}", log_verbose: true)
-          end
-
-          def load!(file_path)
-            ::Dapp::Dapp.shellout!("docker load -i #{file_path}", log_verbose: true)
-          end
-
-          def cache
-            @cache ||= (@cache = {}).tap { cache_reset }
-          end
-
-          def cache_reset(name = '')
-            cache.delete(name)
-            ::Dapp::Dapp.shellout!("docker images --format='{{.Repository}}:{{.Tag}};{{.ID}};{{.CreatedAt}};{{.Size}}' --no-trunc #{name}")
-                        .stdout
-                        .lines
-                        .each do |l|
-              name, id, created_at, size_field = l.split(';').map(&:strip)
-              name = name.reverse.chomp('docker.io/'.reverse).reverse
-              size = begin
-                match = size_field.match(/^(\d+(\.\d+)?)\ ?(b|kb|mb|gb|tb)$/i)
-                raise Error::Build, code: :unsupported_docker_image_size_format, data: {value: size_field} unless match and match[1] and match[3]
-
-                number = match[1].to_f
-                unit = match[3].downcase
-
-                coef = case unit
-                       when 'b'  then 0
-                       when 'kb' then 1
-                       when 'mb' then 2
-                       when 'gb' then 3
-                       when 'tb' then 4
-                       end
-
-                number * (1000**coef)
-              end
-              cache[name] = { id: id, created_at: created_at, size: size }
-            end
-          end
-        end
-      end # Docker
-    end # Image
-  end # Dimg
-end # Dapp