dapp 0.8.0 → 0.9.0

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

@@ -1,32 +0,0 @@
-module Dapp
-  # DockerRegistry
-  module DockerRegistry
-    module Mod
-      # Request
-      module Request
-        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 # Mod
-  end # DockerRegistry
-end # Dapp
-
-Dapp::DockerRegistry::Mod::Request.extend Dapp::DockerRegistry::Mod::Request

data/lib/dapp/error/build.rb

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

data/lib/dapp/error/config.rb

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

data/lib/dapp/error/dimg.rb

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

data/lib/dapp/error/image.rb

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

data/lib/dapp/error/project.rb

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

data/lib/dapp/error/registry.rb

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

data/lib/dapp/error/rugged.rb

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

data/lib/dapp/error/tar_writer.rb

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

data/lib/dapp/exception/introspect_image.rb

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

data/lib/dapp/exception/registry.rb

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

data/lib/dapp/filelock.rb

@@ -1,43 +0,0 @@
-module Dapp
-  # File Monitor
-  module Filelock
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    # ClassMethods
-    module ClassMethods
-      def filelocks
-        @filelocks ||= Hash.new(false)
-      end
-    end
-
-    def filelock(filelock, error_message: 'Already in use!', timeout: 10)
-      return yield if self.class.filelocks[filelock]
-
-      begin
-        self.class.filelocks[filelock] = true
-        filelock_lockfile(filelock, error_message: error_message, timeout: timeout) do
-          yield
-        end
-      ensure
-        self.class.filelocks[filelock] = false
-      end
-    end
-
-    protected
-
-    def filelock_lockfile(filelock, error_message: 'Already in use!', timeout: 10)
-      File.open(home_path(filelock), File::RDWR | File::CREAT, 0o644) do |file|
-        Timeout.timeout(timeout) do
-          file.flock(File::LOCK_EX)
-        end
-
-        yield
-      end
-    rescue Timeout::Error
-      STDERR.puts error_message
-      exit 1
-    end
-  end
-end

data/lib/dapp/git_artifact.rb

@@ -1,241 +0,0 @@
-module Dapp
-  # Artifact from Git repo
-  class GitArtifact
-    attr_reader :repo
-    attr_reader :name
-
-    # rubocop:disable Metrics/ParameterLists
-    def initialize(repo, to:, name: nil, branch: nil, commit: nil,
-                   cwd: nil, include_paths: nil, exclude_paths: nil, owner: nil, group: nil)
-      @repo = repo
-      @name = name
-
-      @branch = branch || repo.dimg.project.cli_options[:git_artifact_branch] || repo.branch
-      @commit = commit
-
-      @to = to
-      @cwd = begin
-        if cwd.nil? || cwd.empty?
-          ''
-        else
-          cwd = File.expand_path(File.join('/', cwd))[1..-1] # must be relative
-          "#{cwd.chomp('/')}/"
-        end
-      end
-      @include_paths = include_paths
-      @exclude_paths = exclude_paths
-      @owner = owner
-      @group = group
-    end
-    # rubocop:enable Metrics/ParameterLists
-
-    def apply_archive_command(stage)
-      credentials = [:owner, :group].map { |attr| "--#{attr}=#{send(attr)}" unless send(attr).nil? }.compact
-
-      [].tap do |commands|
-        commands << "#{repo.dimg.project.install_bin} #{credentials.join(' ')} -d #{to}"
-        commands << "#{sudo}#{repo.dimg.project.tar_bin} -xf #{archive_file(stage.layer_commit(self))} -C #{to}" if any_changes?(nil, stage.layer_commit(self))
-      end
-    end
-
-    def apply_patch_command(stage)
-      patch_command(stage.prev_g_a_stage.layer_commit(self), stage.layer_commit(self))
-    end
-
-    def apply_dev_patch_command(stage)
-      patch_command(stage.prev_g_a_stage.layer_commit(self), nil)
-    end
-
-    def patch_size(from, to)
-      diff_patches(from, to).reduce(0) do |bytes, patch|
-        patch.hunks.each do |hunk|
-          hunk.lines.each do |l|
-            bytes +=
-              case l.line_origin
-              when :eof_newline_added, :eof_newline_removed then 1
-              when :addition, :deletion, :binary            then l.content.size
-              else # :context, :file_header, :hunk_header, :eof_no_newline
-                0
-              end
-          end
-        end
-        bytes
-      end
-    end
-
-    def dev_patch_hash(stage)
-      Digest::SHA256.hexdigest diff_patches(stage.prev_g_a_stage.layer_commit(self), nil).map(&:to_s).join(':::')
-    end
-
-    def latest_commit
-      @latest_commit ||= commit || repo.latest_commit(branch)
-    end
-
-    def paramshash
-      Digest::SHA256.hexdigest [full_name, to, cwd, *include_paths, *exclude_paths, owner, group].map(&:to_s).join(':::')
-    end
-
-    def exclude_paths(with_cwd = false)
-      base_paths(repo.exclude_paths + @exclude_paths, with_cwd)
-    end
-
-    def include_paths(with_cwd = false)
-      base_paths(@include_paths, with_cwd)
-    end
-
-    def base_paths(paths, with_cwd = false)
-      [paths].flatten.compact.map { |path| (with_cwd && cwd ? File.join(cwd, path) : path).gsub(%r{^\/*|\/*$}, '') }
-    end
-
-    def full_name
-      "#{repo.name}#{name ? "_#{name}" : nil}"
-    end
-
-    def any_changes?(from, to = latest_commit)
-      diff_patches(from, to).any?
-    end
-
-    protected
-
-    attr_reader :to
-    attr_reader :commit
-    attr_reader :branch
-    attr_reader :cwd
-    attr_reader :owner
-    attr_reader :group
-
-    def patch_command(prev_commit, current_commit)
-      [].tap do |commands|
-        if any_changes?(prev_commit, current_commit)
-          commands << "#{sudo}#{repo.dimg.project.git_bin} apply --whitespace=nowarn --directory=#{to} --unsafe-paths " \
-                      "#{patch_file(prev_commit, current_commit)}"
-        end
-      end
-    end
-
-    def sudo
-      repo.dimg.project.sudo_command(owner: owner, group: group)
-    end
-
-    def archive_file(commit)
-      create_file(repo.dimg.tmp_path('archives', archive_file_name(commit))) do |f|
-        Gem::Package::TarWriter.new(f) do |tar|
-          diff_patches(nil, commit).each do |patch|
-            entry = patch.delta.new_file
-            tar.add_file slice_cwd(entry[:path]), entry[:mode] do |tf|
-              tf.write repo.lookup_object(entry[:oid]).content
-            end
-          end
-        end
-      end
-      repo.dimg.container_tmp_path('archives', archive_file_name(commit))
-    rescue Gem::Package::TooLongFileName => e
-      raise Error::TarWriter, message: e.message
-    end
-
-    def slice_cwd(path)
-      return path if cwd.empty?
-      path
-        .reverse
-        .chomp(cwd.reverse)
-        .reverse
-    end
-
-    def archive_file_name(commit)
-      file_name(commit, 'tar')
-    end
-
-    def patch_file(from, to)
-      create_file(repo.dimg.tmp_path('patches', patch_file_name(from, to))) do |f|
-        diff_patches(from, to).each { |patch| f.write change_patch_new_file_path(patch) }
-      end
-      repo.dimg.container_tmp_path('patches', patch_file_name(from, to))
-    end
-
-    def change_patch_new_file_path(patch)
-      patch.to_s.lines.tap do |lines|
-        modify_patch_line = proc do |line_number, path_char|
-          action_part, path_part = lines[line_number].split
-          if (path_with_cwd = path_part.partition("#{path_char}/").last).start_with?(cwd)
-            path_with_cwd.sub(cwd, '').tap do |native_path|
-              expected_path = File.join(path_char, native_path)
-              lines[line_number] = [action_part, expected_path].join(' ') + "\n"
-            end
-          end
-        end
-
-        modify_patch = proc do |*modify_patch_line_args|
-          native_paths = modify_patch_line_args.map { |args| modify_patch_line.call(*args) }
-          unless (native_paths = native_paths.compact.uniq).empty?
-            raise Error::Build, code: :unsupported_patch_format, data: { patch: patch.to_s } unless native_paths.one?
-            native_path = native_paths.first
-            lines[0] = ['diff --git', File.join('a', native_path), File.join('b', native_path)].join(' ') + "\n"
-          end
-        end
-
-        case
-        when patch.delta.deleted? then modify_patch.call([3, 'a'])
-        when patch.delta.added? then modify_patch.call([4, 'b'])
-        when patch.delta.modified?
-          if patch_file_mode_changed?(patch)
-            modify_patch.call([4, 'a'], [5, 'b'])
-          else
-            modify_patch.call([2, 'a'], [3, 'b'])
-          end
-        else
-          raise
-        end
-      end.join
-    end
-
-    def patch_file_mode_changed?(patch)
-      patch.delta.old_file[:mode] != patch.delta.new_file[:mode]
-    end
-
-    def patch_file_name(from, to)
-      file_name(from, to, 'patch')
-    end
-
-    def file_name(*args, ext)
-      "#{[full_name, args].flatten.join('_')}.#{ext}"
-    end
-
-    def create_file(file_path, &blk)
-      File.open(file_path, File::RDWR|File::CREAT, &blk)
-    end
-
-    def diff_patches(from, to)
-      (@diff_patches ||= {})[[from, to]] = repo.patches(from, to, paths: include_paths_or_cwd, exclude_paths: exclude_paths(true))
-    end
-
-    def include_paths_or_cwd
-      case
-      when !include_paths(true).empty? then include_paths(true)
-      when !cwd.empty? then [cwd]
-      else
-        []
-      end
-    end
-
-    def exclude_paths(with_cwd = false)
-      base_paths(repo.exclude_paths + @exclude_paths, with_cwd)
-    end
-
-    def include_paths(with_cwd = false)
-      base_paths(@include_paths, with_cwd)
-    end
-
-    def base_paths(paths, with_cwd = false)
-      [paths].flatten.compact.map do |path|
-        if with_cwd && !cwd.empty?
-          File.join(cwd, path)
-        else
-          path
-        end
-          .chomp('/')
-          .reverse.chomp('/')
-          .reverse
-      end
-    end
-  end
-end

data/lib/dapp/git_repo/base.rb

@@ -1,88 +0,0 @@
-module Dapp
-  module GitRepo
-    # Base class for any Git repo (remote, gitkeeper, etc)
-    class Base
-      attr_reader :dimg
-      attr_reader :name
-
-      def initialize(dimg, name)
-        @dimg = dimg
-        @name = name
-      end
-
-      def exclude_paths
-        []
-      end
-
-      def patches(from, to, exclude_paths: [], **kwargs)
-        diff(from, to, **kwargs).patches.select do |patch|
-          !exclude_paths.any? { |p| check_path?(patch.delta.new_file[:path], p) }
-        end
-      end
-
-      def diff(from, to, **kwargs)
-        if from.nil?
-          Rugged::Tree.diff(git, nil, to, **kwargs)
-        else
-          lookup_commit(from).diff(lookup_commit(to), **kwargs)
-        end
-      end
-
-      def commit_exists?(commit)
-        git.exists?(commit)
-      end
-
-      def latest_commit(_branch)
-        raise
-      end
-
-      def branch
-        git.head.name.sub(/^refs\/heads\//, '')
-      end
-
-      def commit_at(commit)
-        lookup_commit(commit).time.to_i
-      end
-
-      def find_commit_id_by_message(regex)
-        walker.each do |commit|
-          next unless commit.message =~ regex
-          return commit.oid
-        end
-      end
-
-      def walker
-        walker = Rugged::Walker.new(git)
-        walker.push(git.head.target_id)
-        walker
-      end
-
-      def lookup_object(oid)
-        git.lookup(oid)
-      end
-
-      def lookup_commit(commit)
-        git.lookup(commit)
-      end
-
-      protected
-
-      def git(**kwargs)
-        @git ||= Rugged::Repository.new(path, **kwargs)
-      end
-
-      private
-
-      def check_path?(path, format)
-        path_parts = path.split('/')
-        checking_path = nil
-
-        until path_parts.empty?
-          checking_path = [checking_path, path_parts.shift].compact.join('/')
-          return true if File.fnmatch(format, checking_path)
-        end
-        false
-      end
-    end
-  end
-end