dapp 0.5.13 → 0.6.0

data/lib/dapp/config/main.rb

@@ -2,8 +2,10 @@ module Dapp
   module Config
     # Main
     class Main < Application
-      def initialize(**options)
-        @_home_path    = Pathname.new(options[:dappfile_path]).parent.expand_path.to_s
+      def initialize(dappfile_path:, project:)
+        @project = project
+
+        @_home_path    = Pathname.new(dappfile_path).parent.expand_path.to_s
         @_basename     = Pathname.new(@_home_path).basename.to_s
         @_builder      = Pathname.new(@_home_path).join('Berksfile').exist? ? :chef : :shell
 
@@ -16,6 +18,7 @@ module Dapp
       end
 
       def name(value)
+        project.log_warning(desc: { code: 'excess_name_instruction', context: 'warning' }) if @_basename == value.to_s
         @_basename = value
       end
     end

data/lib/dapp/config/shell.rb

@@ -2,24 +2,24 @@ module Dapp
   module Config
     # Shell
     class Shell
-      attr_reader :_infra_install, :_infra_setup, :_install, :_setup
-      attr_reader :_infra_install_cache_version, :_infra_setup_cache_version, :_install_cache_version, :_setup_cache_version
+      attr_reader :_before_install, :_before_setup, :_install, :_setup
+      attr_reader :_before_install_cache_version, :_before_setup_cache_version, :_install_cache_version, :_setup_cache_version
 
       def initialize
-        @_infra_install = []
-        @_infra_setup   = []
-        @_install   = []
-        @_setup     = []
+        @_before_install = []
+        @_before_setup   = []
+        @_install       = []
+        @_setup         = []
       end
 
-      def infra_install(*args, cache_version: nil)
-        @_infra_install.concat(args)
-        @_infra_install_cache_version = cache_version
+      def before_install(*args, cache_version: nil)
+        @_before_install.concat(args)
+        @_before_install_cache_version = cache_version
       end
 
-      def infra_setup(*args, cache_version: nil)
-        @_infra_setup.concat(args)
-        @_infra_setup_cache_version = cache_version
+      def before_setup(*args, cache_version: nil)
+        @_before_setup.concat(args)
+        @_before_setup_cache_version = cache_version
       end
 
       def install(*args, cache_version: nil)
@@ -32,12 +32,12 @@ module Dapp
         @_setup_cache_version = cache_version
       end
 
-      def reset_infra_install
-        @_infra_install = []
+      def reset_before_install
+        @_before_install = []
       end
 
-      def reset_infra_setup
-        @_infra_setup = []
+      def reset_before_setup
+        @_before_setup = []
       end
 
       def reset_install
@@ -52,6 +52,10 @@ module Dapp
         methods.tap { |arr| arr.delete(__method__) }.grep(/^reset_/).each(&method(:send))
       end
 
+      def empty?
+        @_before_install.empty? && @_before_setup.empty? && @_install.empty? && @_setup.empty?
+      end
+
       def clone
         Marshal.load(Marshal.dump(self))
       end

data/lib/dapp/docker_registry.rb

@@ -0,0 +1,32 @@
+module Dapp
+  # DockerRegistry
+  module DockerRegistry
+    def self.new(repo)
+      repo_regex =~ repo
+      expected_hostname = Regexp.last_match(1)
+      expected_repo_suffix = Regexp.last_match(2)
+      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_regex
+      separator = /[_.]|__|[-]*/
+      alpha_numeric = /[[:alnum:]]*/
+      component = /#{alpha_numeric}[#{separator}#{alpha_numeric}]*/
+      port_number = /[0-9]+/
+      hostcomponent = /[[:alnum:]-]*[[:alnum:]]/
+      hostname = /#{hostcomponent}[\.#{hostcomponent}]*[:#{port_number}]?/
+      %r{^(#{hostname}/)?(#{component}[/#{component}]*)$}
+    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

@@ -0,0 +1,47 @@
+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']
+      end
+
+      def image_id_by_tag(tag)
+        response = api_request(repo_suffix, "/manifests/#{tag}", headers: { Accept: 'application/vnd.docker.distribution.manifest.v2+json' })
+        response['config']['digest'] if response['schemaVersion'] == 2
+      end
+
+      protected
+
+      def api_request(*uri, **options)
+        JSON.load(request(api_url(*uri), expects: [200], **options).body)
+      rescue Excon::Error::NotFound
+        raise Error::Registry, code: :not_found
+      end
+
+      def api_url(*uri)
+        File.join(hostname_url, API_VERSION, '/', *uri)
+      end
+    end
+  end # DockerRegistry
+end # Dapp

data/lib/dapp/docker_registry/default.rb

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

@@ -0,0 +1,62 @@
+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}" } }
+            else raise Error::Registry, code: :authenticate_type_not_supported
+            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 })
+          raise Error::Registry, code: :user_not_authorized if credential.nil?
+          credential['auth']
+        end
+
+        def auths_section_from_docker_config
+          file = Pathname(File.join(Dir.home, '.docker', 'config.json'))
+          raise Error::Registry, code: :user_not_authorized unless file.exist?
+          JSON.load(file.read)['auths'].tap { |auths| raise Error::Registry, code: :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

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

@@ -0,0 +1,44 @@
+module Dapp
+  # DockerRegistry
+  module DockerRegistry
+    module Mod
+      # Request
+      module Request
+        def request(url, **options)
+          raw_request(url, deep_merge(options, authorization_options(url)))
+        end
+
+        def raw_request(url, **options)
+          Excon.new(url).request(deep_merge(default_request_options, 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
+
+        private
+
+        def deep_merge(hash1, hash2)
+          hash1.merge(hash2) do |_, v1, v2|
+            if v1.is_a?(Hash) && v2.is_a?(Hash)
+              v1.merge(v2)
+            else
+              [v1, v2].flatten
+            end
+          end
+        end
+      end
+    end # Mod
+  end # DockerRegistry
+end # Dapp
+
+Dapp::DockerRegistry::Mod::Request.extend Dapp::DockerRegistry::Mod::Request

data/lib/dapp/error/image.rb

@@ -0,0 +1,6 @@
+module Dapp
+  module Error
+    # Image
+    class Image < Base; end
+  end
+end

data/lib/dapp/error/project.rb

@@ -0,0 +1,6 @@
+module Dapp
+  module Error
+    # Project
+    class Project < Base; end
+  end
+end

data/lib/dapp/error/registry.rb

@@ -0,0 +1,6 @@
+module Dapp
+  module Error
+    # Registry
+    class Registry < Base; end
+  end
+end

data/lib/dapp/exception/registry.rb

@@ -0,0 +1,6 @@
+module Dapp
+  module Exception
+    # Registry
+    class Registry < Base; end
+  end
+end

data/lib/dapp/git_artifact.rb

@@ -12,10 +12,9 @@ module Dapp
 
       @where_to_add = where_to_add
 
-      @branch = branch || repo.application.cli_options[:git_artifact_branch] || repo.branch
+      @branch = branch || repo.application.project.cli_options[:git_artifact_branch] || repo.branch
       @commit = commit
 
-      cwd = File.expand_path(File.join('/', cwd))[1..-1] unless cwd.nil? || cwd.empty?
       @cwd = cwd
       @paths = paths
       @owner = owner
@@ -27,17 +26,17 @@ module Dapp
       credentials = [:owner, :group].map { |attr| "--#{attr}=#{send(attr)}" unless send(attr).nil? }.compact
 
       ["install #{credentials.join(' ')} -d #{where_to_add}",
-       ["#{repo.application.git_path} --git-dir=#{repo.container_path} archive #{stage.layer_commit(self)}:#{cwd} #{paths}",
+       ["git --git-dir=#{repo.container_path} archive #{stage.layer_commit(self)}:#{cwd} #{paths}",
         "#{sudo}tar -x -C #{where_to_add}"].join(' | ')]
     end
 
     def apply_patch_command(stage)
       current_commit = stage.layer_commit(self)
-      prev_commit = stage.prev_source_stage.layer_commit(self)
+      prev_commit = stage.prev_g_a_stage.layer_commit(self)
 
       if prev_commit != current_commit || any_changes?(prev_commit, current_commit)
-        [["#{repo.application.git_path} --git-dir=#{repo.container_path} #{diff_command(prev_commit, current_commit)}",
-          "#{sudo}#{repo.application.git_path} apply --whitespace=nowarn --directory=#{where_to_add} --unsafe-paths"].join(' | ')]
+        [["git --git-dir=#{repo.container_path} #{diff_command(prev_commit, current_commit)}",
+          "#{sudo}git apply --whitespace=nowarn --directory=#{where_to_add} --unsafe-paths"].join(' | ')]
       else
         []
       end
@@ -84,7 +83,7 @@ module Dapp
       sudo = ''
 
       if owner || group
-        sudo = "#{repo.application.sudo_path} -E "
+        sudo = 'sudo -E '
         sudo += "-u #{sudo_format_user(owner)} " if owner
         sudo += "-g #{sudo_format_user(group)} " if group
       end

data/lib/dapp/git_repo/base.rb

@@ -44,7 +44,7 @@ module Dapp
       protected
 
       def git(command, **kwargs)
-        application.system_shellout! "#{application.git_path} #{command}", **kwargs
+        application.project.shellout!("git #{command}", **kwargs)
       end
     end
   end

data/lib/dapp/git_repo/remote.rb

@@ -2,28 +2,20 @@ module Dapp
   module GitRepo
     # Normal Git repo
     class Remote < Base
-      def initialize(application, name, url:, ssh_key_path: nil)
+      def initialize(application, name, url:)
         super(application, name)
 
         @url = url
-        @ssh_key_path = File.expand_path(ssh_key_path, application.home_path) if ssh_key_path
 
-        @use_ssh_key = false
-        File.chmod(0o600, @ssh_key_path) if @ssh_key_path
-
-        with_ssh_key do
-          application.log_secondary_process(application.t(code: 'process.git_artifact_clone', data: { name: name }), short: true) do
-            git "clone --bare --depth 1 #{url} #{path}"
-          end
+        application.project.log_secondary_process(application.project.t(code: 'process.git_artifact_clone', data: { name: name }), short: true) do
+          git "clone --bare --depth 1 #{url} #{path}"
         end unless File.directory?(path)
       end
 
       def fetch!(branch = 'master')
-        with_ssh_key do
-          application.log_secondary_process(application.t(code: 'process.git_artifact_fetch', data: { name: name }), short: true) do
-            git_bare "fetch origin #{branch}:#{branch}"
-          end
-        end unless application.ignore_git_fetch || application.dry_run?
+        application.project.log_secondary_process(application.project.t(code: 'process.git_artifact_fetch', data: { name: name }), short: true) do
+          git_bare "fetch origin #{branch}:#{branch}"
+        end unless application.ignore_git_fetch || application.project.dry_run?
       end
 
       def cleanup!
@@ -34,30 +26,6 @@ module Dapp
       protected
 
       attr_reader :url
-      attr_reader :ssh_key_path
-
-      attr_accessor :use_ssh_key
-      def use_ssh_key
-        @use_ssh_key ||= false
-      end
-
-      def with_ssh_key
-        original = use_ssh_key
-        self.use_ssh_key = true
-
-        yield
-      ensure
-        self.use_ssh_key = original
-      end
-
-      def git(command, **kwargs)
-        if use_ssh_key && ssh_key_path
-          cmd = application.shellout_pack("/tmp/dapp_system_shellout/usr/bin/ssh-agent bash -ec '/tmp/dapp_system_shellout/usr/bin/ssh-add #{ssh_key_path}; #{application.git_path} #{command}'")
-          application.system_shellout!("bash -ec '#{cmd}'")
-        else
-          super
-        end
-      end
     end
   end
 end

data/lib/dapp/helper/sha256.rb

@@ -8,9 +8,9 @@ module Dapp
 
       def paths_content_hashsum(paths)
         paths.map(&:to_s)
-          .reject { |path| File.directory?(path) }
-          .sort
-          .reduce(nil) { |hash, path| hashsum [hash, File.read(path)].compact }
+             .reject { |path| File.directory?(path) }
+             .sort
+             .reduce(nil) { |hash, path| hashsum [hash, File.read(path)].compact }
       end
 
       def sha256(arg)