dapp 0.8.0 → 0.9.0

data/lib/dapp/config/directive/shell/artifact.rb

@@ -1,17 +0,0 @@
-module Dapp
-  module Config
-    module Directive
-      module Shell
-        # Artifact
-        class Artifact < Dimg
-          attr_reader :_build_artifact
-          stage_command_generator(:build_artifact)
-
-          def empty?
-            super && _build_artifact_command.empty?
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-module Dapp
-  module Config
-    module Directive
-      module Shell
-        # Dimg
-        class Dimg < Directive::Base
-          attr_reader :_version
-          attr_reader :_before_install, :_before_setup, :_install, :_setup
-
-          def version(value)
-            @_version = value
-          end
-
-          def self.stage_command_generator(stage)
-            define_method stage do |&blk|
-              (variable = instance_variable_get("@_#{stage}") || StageCommand.new(project: project)).instance_eval(&blk)
-              instance_variable_set("@_#{stage}", variable)
-            end
-
-            define_method "_#{stage}_command" do
-              return [] if (variable = instance_variable_get("@_#{stage}")).nil?
-              variable._run
-            end
-
-            define_method "_#{stage}_version" do
-              return [] if (variable = instance_variable_get("@_#{stage}")).nil?
-              variable._version || _version
-            end
-          end
-          [:before_install, :before_setup, :install, :setup].each(&method(:stage_command_generator))
-
-          # StageCommand
-          class StageCommand < Directive::Base
-            attr_reader :_version
-            attr_reader :_run
-
-            def initialize(**kwargs, &blk)
-              @_run = []
-
-              super(**kwargs, &blk)
-            end
-
-            def run(*args)
-              @_run.concat(args)
-            end
-
-            def version(value)
-              @_version = value
-            end
-          end
-
-          protected
-
-          def empty?
-            (_before_install_command + _before_setup_command + _install_command + _setup_command).empty?
-          end
-
-          def clone_to_artifact
-            _clone_to Artifact.new(project: project)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/dapp/dimg/path.rb

@@ -1,37 +0,0 @@
-module Dapp
-  # Dimg
-  class Dimg
-    # Path
-    module Path
-      def home_path(*path)
-        make_path(project.path, *path).expand_path
-      end
-
-      def tmp_path(*path)
-        @tmp_path ||= Dir.mktmpdir('dapp-', project.cli_options[:tmp_dir_prefix] || '/tmp')
-        make_path(@tmp_path, *path).expand_path.tap { |p| p.parent.mkpath }
-      end
-
-      def build_path(*path)
-        make_path(project.build_path, *path).expand_path.tap { |p| p.parent.mkpath }
-      end
-
-      def container_dapp_path(*path)
-        make_path('/.dapp', *path)
-      end
-
-      def container_tmp_path(*path)
-        container_dapp_path('tmp', *path)
-      end
-
-      alias_method :build_dir, :build_path
-      alias_method :tmp_dir, :tmp_path
-
-      private
-
-      def make_path(base, *path)
-        path.compact.map(&:to_s).inject(Pathname.new(base), &:+)
-      end
-    end # Path
-  end # Dimg
-end # Dapp

data/lib/dapp/dimg/stages.rb

@@ -1,59 +0,0 @@
-module Dapp
-  # Dimg
-  class Dimg
-    # Stages
-    module Stages
-      def signature
-        last_stage.send(:signature)
-      end
-
-      def stage_cache_format
-        "#{project.stage_cache}:%{signature}"
-      end
-
-      def stage_dapp_label
-        project.stage_dapp_label
-      end
-
-      def all_images
-        @all_images ||= all_stages.map(&:image).uniq!(&:name)
-      end
-
-      protected
-
-      def last_stage
-        @last_stage ||= if scratch?
-                          Build::Stage::ImportArtifact.new(self)
-                        else
-                          Build::Stage::DockerInstructions.new(self)
-                        end
-      end
-
-      def export_images
-        all_images.select(&:tagged?)
-      end
-
-      def import_images
-        all_images.select { |image| !image.tagged? }
-      end
-
-      def stages
-        (@stages ||= []).tap do |stages|
-          stage = last_stage
-          loop do
-            stages << stage
-            break if (stage = stage.prev_stage).nil?
-          end
-        end
-      end
-
-      def artifacts_stages
-        @artifacts_stages ||= stages.select { |stage| stage.artifact? }
-      end
-
-      def all_stages
-        stages + artifacts.map(&:all_stages).flatten
-      end
-    end # Stages
-  end # Dimg
-end # Dapp

data/lib/dapp/dimg/tags.rb

@@ -1,65 +0,0 @@
-module Dapp
-  # Dimg
-  class Dimg
-    # Tags
-    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
-        project.cli_options[:tag]
-      end
-
-      def branch_tags
-        return [] unless project.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 project.cli_options[:tag_commit]
-        commit = git_repo.latest_commit
-        [commit]
-      end
-
-      def build_tags
-        return [] unless project.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 project.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 # Dimg
-end # Dapp

data/lib/dapp/docker_registry.rb

@@ -1,36 +0,0 @@
-module Dapp
-  # DockerRegistry
-  module DockerRegistry
-    def self.new(repo)
-      /^#{repo_name_format}$/ =~ repo
-      expected_hostname = Regexp.last_match(:hostname)
-      expected_repo_suffix = Regexp.last_match(:repo_suffix)
-      expected_hostname_url = expected_hostname ? "http://#{expected_hostname}" : nil
-
-      if hostname_exist?(expected_hostname_url)
-        Base.new(repo, expected_hostname_url, expected_repo_suffix)
-      else
-        Default.new(repo, File.join(*[expected_hostname, expected_repo_suffix].compact))
-      end
-    end
-
-    def self.repo_name_format
-      separator = '[_.]|__|[-]*'
-      alpha_numeric = '[[:alnum:]]*'
-      component = "#{alpha_numeric}[#{separator}#{alpha_numeric}]*"
-      port_number = '[[:digit:]]+'
-      hostcomponent = '[[:alnum:]_-]*[[:alnum:]]'
-      hostname = "#{hostcomponent}[\\.#{hostcomponent}]*(?<port>:#{port_number})?"
-      "(?<hostname>#{hostname}/)?(?<repo_suffix>#{component}[/#{component}]*)"
-    end
-
-    def self.repo_name?(name)
-      !(/^#{repo_name_format}$/ =~ name).nil?
-    end
-
-    def self.hostname_exist?(url)
-      return false unless url
-      Mod::Request.url_available?(url)
-    end
-  end # DockerRegistry
-end # Dapp

data/lib/dapp/docker_registry/base.rb

@@ -1,109 +0,0 @@
-module Dapp
-  # DockerRegistry
-  module DockerRegistry
-    # Base
-    class Base
-      include Mod::Request
-      include Mod::Authorization
-
-      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 repo_exist?
-        tags.any?
-      end
-
-      def tags
-        @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)
-        response = manifest_v2(tag)
-        response['config']['digest'] if response['schemaVersion'] == 2
-      end
-
-      def image_parent_id(tag)
-        image_history(tag)['container_config']['Image']
-      end
-
-      def image_labels(tag)
-        image_history(tag)['config']['Labels']
-      end
-
-      def image_delete(tag)
-        image_blobs(tag).each { |hash| blob_delete(hash.values.first) }
-        api_request(repo_suffix, "/manifests/#{image_digest(tag)}",
-                    method: :delete,
-                    expects: [202, 404],
-                    headers: { Accept: 'Accept: application/vnd.docker.distribution.manifest.v2+json' })
-      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']
-      end
-
-      def image_blobs(tag)
-        manifest_v1(tag)['fsLayers']
-      end
-
-      def manifest_v1(tag)
-        api_request(repo_suffix, "/manifests/#{tag}")
-      end
-
-      def manifest_v2(tag)
-        api_request(repo_suffix, "/manifests/#{tag}",
-                    headers: { Accept: 'application/vnd.docker.distribution.manifest.v2+json' })
-      end
-
-      def blob_delete(id)
-        api_request(repo_suffix, "/blobs/#{id}",
-                    method: :delete, expects: [202, 404])
-      end
-
-      def api_request(*uri, **options)
-        JSON.load(raw_api_request(*uri, **options).body)
-      end
-
-      def raw_api_request(*uri, **options)
-        url = api_url(*uri)
-        request(url, **default_api_options.merge(options))
-      rescue Excon::Error::NotFound
-        raise Error::Registry, code: :page_not_found, data: { url: url, registry: api_url }
-      rescue Excon::Error::Unauthorized
-        user_not_authorized!
-      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 Error::Registry, code: :user_not_authorized, data: { registry: api_url }
-      end
-    end
-  end # DockerRegistry
-end # Dapp

data/lib/dapp/docker_registry/default.rb

@@ -1,18 +0,0 @@
-module Dapp
-  # DockerRegistry
-  module DockerRegistry
-    # Default
-    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 # Dapp

data/lib/dapp/docker_registry/mod/authorization.rb

@@ -1,63 +0,0 @@
-module Dapp
-  # DockerRegistry
-  module DockerRegistry
-    module Mod
-      # Authorization
-      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 # Mod
-  end # DockerRegistry
-end # Dapp