dapp 0.8.0 → 0.9.0

data/lib/dapp/dimg/dimg/git_artifact.rb

@@ -0,0 +1,26 @@
+module Dapp
+  module Dimg
+    class Dimg
+      module GitArtifact
+        def git_artifacts
+          [*local_git_artifacts, *remote_git_artifacts].compact
+        end
+
+        def local_git_artifacts
+          @local_git_artifact_list ||= Array(config._git_artifact._local).map do |ga_config|
+            repo = GitRepo::Own.new(self)
+            ::Dapp::Dimg::GitArtifact.new(repo, **ga_config._artifact_options)
+          end
+        end
+
+        def remote_git_artifacts
+          @remote_git_artifact_list ||= Array(config._git_artifact._remote).map do |ga_config|
+            repo = GitRepo::Remote.new(self, ga_config._name, url: ga_config._url)
+            repo.fetch!(ga_config._branch)
+            ::Dapp::Dimg::GitArtifact.new(repo, **ga_config._artifact_options)
+          end
+        end
+      end # GitArtifact
+    end # Mod
+  end # Dimg
+end # Dapp

data/lib/dapp/dimg/dimg/path.rb

@@ -0,0 +1,37 @@
+module Dapp
+  module Dimg
+    class Dimg
+      module Path
+        def home_path(*path)
+          make_path(dapp.path, *path).expand_path
+        end
+
+        def tmp_path(*path)
+          @tmp_path ||= Dir.mktmpdir('dapp-', dapp.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(dapp.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 build_dir build_path
+        alias tmp_dir tmp_path
+
+        private
+
+        def make_path(base, *path)
+          path.compact.map(&:to_s).inject(Pathname.new(base), &:+)
+        end
+      end # Path
+    end
+  end # Dimg
+end # Dapp

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

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

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

@@ -0,0 +1,65 @@
+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.rb

@@ -0,0 +1,37 @@
+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)
+        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
+        Base.url_available?(url)
+      end
+    end # DockerRegistry
+  end # Dimg
+end # Dapp

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

@@ -0,0 +1,109 @@
+module Dapp
+  module Dimg
+    module DockerRegistry
+      class Base
+        include Request
+        include 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 # Dimg
+end # Dapp

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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,18 @@
+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