dapp 0.35.23 → 0.35.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de9a6a59f4ca7c02846087b2048a5764325e882353d5e0ec725832b21adf9fff
-  data.tar.gz: 1dbfc5b27f38e35762ca15b390237054e5e64e441cb2d6fb67355961086b4ae0
+  metadata.gz: be6da76fd071625161bf829c7004669e9d32e1049bc76fbc47e5f4e5405c1121
+  data.tar.gz: 6e82c044625221031d1c10094935e48134fe088149ee976a92bc7a6309def346
 SHA512:
-  metadata.gz: 6b0d4a4a8bf96e2fc41c72aa325a80155ff237186fbf178a89cf7bef3548e835c66bca3ed4966b3874dba9a9ce65a2f24ac5ac184fc5fd8669f7ec2e29cb178e
-  data.tar.gz: a9e60783f5e63fc112a604faab32676f5c14500b038eb8eaf0c136a1f4d050bf3c7e3476207214a354c884058684554a18b4787fac7d48d0d9e25daa0f0f80f0
+  metadata.gz: c748e01641e9c531840ccc9dd8238dbb04b2acef4340b4698785ff6db7290040979a1153f67fe8d587bce1e65b48ee639864982b27b203215ac322f7e9916dc4
+  data.tar.gz: 38bd43546751b84d7962bfb19a8a6e817bc911f168cc335a07db9f62904f3453a37a32a4bd81144882643c83da750bfb45682ebd520a7ca7a79552ba100938ab

data/lib/dapp/dapp.rb

@@ -102,9 +102,6 @@ module Dapp
     def git_url
       return unless git_own_repo_exist?
       git_own_repo.remote_origin_url
-    rescue Dimg::Error::Rugged => e
-      return if e.net_status[:code] == :git_repository_without_remote_url
-      raise
     end
 
     def git_own_repo_exist?

data/lib/dapp/dapp/chef.rb

@@ -1,14 +1,6 @@
 module Dapp
   class Dapp
     module Chef
-      def local_git_artifact_exclude_paths(&blk)
-        super do |exclude_paths|
-          exclude_paths << '.dapp_chef'
-
-          yield exclude_paths if block_given?
-        end
-      end
-
       def builder_cookbook_path
         path('.dapp_chef')
       end

data/lib/dapp/dapp/dappfile.rb

@@ -12,16 +12,6 @@ module Dapp
         end
       end
 
-      def local_git_artifact_exclude_paths(&blk)
-        super do |exclude_paths|
-          exclude_paths << 'Dappfile'
-          exclude_paths << "dappfile.yml"
-          exclude_paths << "dappfile.yaml"
-
-          yield exclude_paths if block_given?
-        end
-      end
-
       def expand_path(path, number = 1)
         path = File.expand_path(path)
         number.times.each { path = File.dirname(path) }

data/lib/dapp/dapp/option_tags.rb

@@ -47,7 +47,7 @@ module Dapp
 
       def branch_tags
         return {} unless options[:tag_branch]
-        raise Error::Dapp, code: :git_branch_without_name if (branch = git_own_repo.branch) == 'HEAD'
+        raise Error::Dapp, code: :git_branch_without_name if (branch = git_own_repo.head_branch_name) == 'HEAD'
         { git_branch: [branch] }
       end
 

data/lib/dapp/dapp/sentry.rb

@@ -58,13 +58,12 @@ module Dapp
         }.tap {|extra|
           if git_own_repo_exist?
             extra["git"] = {}.tap do |extra_git|
-              if git_own_repo.tracked_remote_repository?
+              if git_own_repo.remote_origin_url
                 extra_git["remote_origin_url"] = git_own_repo.remote_origin_url, # may contain https token
                 extra_git["name"] = self.git_url_to_name(git_own_repo.remote_origin_url)
               end
 
               extra_git["path"] = git_own_repo.path
-              extra_git["workdir_path"] = git_own_repo.workdir_path
               extra_git["latest_commit"] = git_own_repo.head_commit unless git_own_repo.empty?
             end
           end
@@ -84,7 +83,7 @@ module Dapp
           "dapp-build-cache-version" => ::Dapp::BUILD_CACHE_VERSION,
           "dapp-command" => self.options[:dapp_command],
         }.tap {|tags|
-          if git_own_repo_exist? && git_own_repo.tracked_remote_repository?
+          if git_own_repo_exist? && git_own_repo.remote_origin_url
             tags["git-host"] = self.get_host_from_git_url(git_own_repo.remote_origin_url)
 
             git_name = self.git_url_to_name(git_own_repo.remote_origin_url)

data/lib/dapp/dimg/build/stage/ga_archive.rb

@@ -3,8 +3,6 @@ module Dapp
     module Build
       module Stage
         class GAArchive < GABase
-          RESET_COMMIT_MESSAGES = ['[dapp reset]', '[reset dapp]'].freeze
-
           def initialize(dimg, next_stage)
             @prev_stage = BeforeInstallArtifact.new(dimg, self)
             super
@@ -22,8 +20,7 @@ module Dapp
           protected
 
           def reset_commits
-            regex = Regexp.union(RESET_COMMIT_MESSAGES)
-            dimg.git_artifacts.map { |git_artifact| git_artifact.repo.find_commit_id_by_message(regex) }.compact.sort.uniq
+            dimg.git_artifacts.map { |git_artifact| git_artifact.repo.find_commit_id_by_message('(\[dapp reset\])|(\[reset dapp\])') }.compact.sort.uniq
           end
 
           def apply_command_method

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

@@ -13,9 +13,12 @@ module Dapp
           @name = name
         end
 
+        def exclude_paths
+          []
+        end
+
         def get_ruby2go_state_hash
           {
-            "Dapp" => dapp.get_ruby2go_state_hash,
             "Name" => @name.to_s,
           }
         end
@@ -24,208 +27,50 @@ module Dapp
           @name = state["Name"]
         end
 
-        def exclude_paths
-          []
-        end
-
-        def remote_origin_url
-          @remote_origin_url ||= begin
-            ro_url = url
-            while url_protocol(ro_url) == :noname
-              begin
-                parent_git = Rugged::Repository.discover(ro_url)
-              rescue Rugged::OSError
-                parent_git_path = parent_git ? parent_git.path : path
-                raise Error::Rugged, code: :git_repository_not_found, data: { path: ro_url, parent_git_path: parent_git_path }
-              end
-
-              ro_url = begin
-                git_url(parent_git)
-              rescue Error::Rugged => e
-                break if e.net_status[:code] == :git_repository_without_remote_url # local repository
-                raise
-              end
-            end
-
-            ro_url
-          end
-        end
-
-        def remote_origin_url_protocol
-          url_protocol(remote_origin_url)
-        end
-
-        def nested_git_directories_patches(*_args)
-          raise
-        end
-
-        def submodules_params(commit, paths: [], exclude_paths: [])
-          raise "Workdir not supported for `#{self.class}` repository" if commit.nil?
-          submodules(commit, paths: paths, exclude_paths: exclude_paths).map(&method(:submodule_params))
-        end
-
-        def submodule_params(submodule)
-          {}.tap do |params|
-            params[:path]   = submodule.path
-            params[:url]    = begin
-              params_url = submodule_url(submodule.url)
-              params_url = "#{params_url}.git" if url_protocol(params[:url]) != :noname && !params_url.end_with?('.git')
-              params_url
-            end # https://github.com/libgit2/rugged/issues/761
-
-            params[:type] = begin
-              if url_protocol(params[:url]) == :noname
-                submodule_absolute_path = File.join(File.dirname(path), params[:path])
-                dapp.log_warning(desc: { code: :submodule_url_scheme_not_detected,
-                                         data: { url: params[:url], path: submodule_absolute_path } })
-                :local
-              else
-                :remote
-              end
-            end
-            params[:commit] = submodule.head_oid
-          end
-        end
-
-        def submodules(commit, paths: [], exclude_paths: [])
-          Rugged::SubmoduleCollection.new(submodules_git(commit)).select do |submodule|
-            next false if ignore_directory?(submodule.path, paths: paths, exclude_paths: exclude_paths)
-            next true  if submodule.in_config?
-            dapp.log_warning(desc: { code: :submodule_mapping_not_found,
-                                     data: { path: submodule.path, repo: name } })
-          end
-        end
-
-        def submodules_git(commit)
-          submodules_git_path(commit).tap do |git_path|
-            break begin
-              if git_path.directory?
-                Rugged::Repository.new(git_path.to_s)
-              else
-                Rugged::Repository.clone_at(path.to_s, git_path.to_s).tap do |submodules_git|
-                  begin
-                    submodules_git.checkout(commit, strategy: :force)
-                  rescue Rugged::ReferenceError
-                    raise_submodule_commit_not_found!(commit)
-                  end
-                end
-              end
-            end
-          end
-        end
-
-        def submodules_git_path(commit)
-          Pathname(File.join(dapp.host_docker_tmp_config_dir, "submodule", dapp.consistent_uniq_slugify(name), commit).to_s)
-        end
-
-        def raise_submodule_commit_not_found!(_)
-          raise
+        def empty?
+          return @empty if !@empty.nil?
+          @empty = ruby2go_method("IsEmpty")
+          @empty
         end
 
-        def submodule_url(gitsubmodule_url)
-          if gitsubmodule_url.start_with?('../')
-            case remote_origin_url_protocol
-            when :http, :https, :git
-              uri = URI.parse(remote_origin_url)
-              uri.path = File.expand_path(File.join(uri.path, gitsubmodule_url))
-              uri.to_s
-            when :ssh
-              host_with_user, group_and_project = remote_origin_url.split(':', 2)
-              group_and_project = File.expand_path(File.join('/', group_and_project, gitsubmodule_url))[1..-1]
-              [host_with_user, group_and_project].join(':')
-            else
-              raise
-            end
-          else
-            gitsubmodule_url
-          end
+        def find_commit_id_by_message(regex)
+          ruby2go_method("FindCommitIdByMessage", "regex" => regex)
         end
 
-        # FIXME: Убрать логику исключения путей exclude_paths из данного класса,
-        # FIXME: т.к. большинство методов не поддерживают инвариант
-        # FIXME "всегда выдавать данные с исключенными путями".
-        # FIXME: Например, метод diff выдает данные без учета exclude_paths.
-        # FIXME: Лучше перенести фильтрацию в GitArtifact::diff_patches.
-        # FIXME: ИЛИ обеспечить этот инвариант, но это ограничит в возможностях
-        # FIXME: использование Rugged извне этого класса и это более сложный путь.
-        # FIXME: Лучше сейчас убрать фильтрацию, а добавить ее когда наберется достаточно
-        # FIXME: примеров использования.
-
-        def patches(from, to, paths: [], exclude_paths: [], **kwargs)
-          diff(from, to, **kwargs).patches.select do |patch|
-            !ignore_patch?(patch, paths: paths, exclude_paths: exclude_paths)
-          end
+        def commit_exists?(commit)
+          ruby2go_method("IsCommitExists", "commit" => commit)
         end
 
-        def ignore_patch?(patch, paths: [], exclude_paths: [])
-          ignore_path?(patch.delta.new_file[:path], paths: paths, exclude_paths: exclude_paths)
-        end
+        def remote_origin_url
+          return @remote_origin_url if @remote_origin_url_set
 
-        def blobs_entries(commit, paths: [], exclude_paths: [])
-          [].tap do |entries|
-            lookup_commit(commit).tree.walk_blobs(:preorder) do |root, entry|
-              fullpath = File.join(root, entry[:name]).reverse.chomp('/').reverse
-              next if ignore_path?(fullpath, paths: paths, exclude_paths: exclude_paths)
-              entries << [root, entry]
-            end
+          res = ruby2go_method("RemoteOriginUrl")
+          if res != ""
+            @remote_origin_url = res
           end
-        end
+          @remote_origin_url_set = true
 
-        def diff(from, to, **kwargs)
-          if to.nil?
-            raise "Workdir diff not supported for #{self.class}"
-          elsif from.nil?
-            Rugged::Tree.diff(git, nil, to, **kwargs)
-          else
-            lookup_commit(from).diff(lookup_commit(to), **kwargs)
-          end
+          @remote_origin_url
         end
 
-        def commit_exists?(commit)
-          git.exists?(commit)
+        def latest_branch_commit(branch)
+          ruby2go_method("LatestBranchCommit", "branch" => branch)
         end
 
         def head_commit
-          git.head.target_id
-        end
-
-        def latest_branch_commit(_)
-          raise
-        end
-
-        def latest_tag_commit(_)
-          raise
-        end
-
-        def branch
-          git.head.name.sub(/^refs\/heads\//, '')
-        rescue Rugged::ReferenceError => e
-          raise Error::Rugged, code: :git_repository_reference_error, data: { name: name, message: e.message.downcase }
-        end
-
-        def tags
-          git.tags.map(&:name)
+          return @head_commit if !@head_commit.nil?
+          @head_commit = ruby2go_method("HeadCommit")
+          @head_commit
         end
 
-        def remote_branches
-          git.branches
-            .map(&:name)
-            .select { |b| b.start_with?('origin/') }
-            .map { |b| b.reverse.chomp('origin/'.reverse).reverse }
+        def head_branch_name
+          return @branch if !@branch.nil?
+          @branch = ruby2go_method("HeadBranchName")
+          @branch
         end
 
-        def find_commit_id_by_message(regex)
-          walker.each do |commit|
-            msg = commit.message.encode('UTF-8', invalid: :replace, undef: :replace)
-            return commit.oid if msg =~ regex
-          end
-        end
-
-        def walker
-          walker = Rugged::Walker.new(git)
-          walker.push(git.head.target_id)
-          walker
-        end
+        # TODO Below operations does not affect build process, only used in sample.
+        # TODO Should be ported to golang without git_repo.GitRepo interface.
 
         def lookup_object(oid)
           git.lookup(oid)
@@ -235,54 +80,16 @@ module Dapp
           git.lookup(commit)
         end
 
-        def empty?
-          git.empty?
-        end
-
-        def tracked_remote_repository?
-          !git.remotes.to_a.empty?
-        end
-
         protected
 
-        def git(**kwargs)
-          @git ||= Rugged::Repository.new(path.to_s, **kwargs)
-        end
-
-        def url
-          @url ||= git_config_remote_origin_url(git)
-        end
-
-        def git_url(git_repo)
-          git_config_remote_origin_url(git_repo)
-        end
-
-        def git_config_remote_origin_url(git_repo)
-          git_repo.config.to_hash['remote.origin.url'].tap do |url|
-            raise Error::Rugged, code: :git_repository_without_remote_url, data: { name: self.class, path: git_repo.path } if url.nil?
-          end
-        end
-
-        def url_protocol(url)
-          if (scheme = URI.parse(url).scheme).nil?
-            :noname
-          else
-            scheme.to_sym
-          end
-        rescue URI::InvalidURIError
-          :ssh
-        rescue Error::Rugged => e
-          return :none if e.net_status[:code] == :git_repository_without_remote_url
+        def ruby2go_method(method, args_hash={})
           raise
         end
 
-        private
-
-        def ignore_directory?(path, paths: [], exclude_paths: [])
-          ignore_path_base(path, exclude_paths: exclude_paths) do
-            paths.empty? || paths.any? { |p| check_path?(path, p) || check_subpath?(path, p) }
-          end
+        def git(**kwargs) # TODO remove
+          @git ||= Rugged::Repository.new(path.to_s, **kwargs)
         end
+
       end
     end
   end

data/lib/dapp/dimg/git_repo/local.rb

@@ -18,75 +18,20 @@ module Dapp
           }
         end
 
-        def path=(path)
-          @path ||= Pathname(Rugged::Repository.new(path).path)
-        rescue Rugged::RepositoryError, Rugged::OSError => _e
-          raise Error::Rugged, code: :local_git_repository_does_not_exist, data: { path: path }
-        end
-
-        def workdir_path
-          Pathname(git.workdir)
-        end
-
-        def nested_git_directories_patches(paths: [], exclude_paths: [], **kwargs)
-          patches(nil, nil, paths: paths, exclude_paths: exclude_paths, **kwargs).select do |patch|
-            delta_new_file = patch.delta.new_file
-            nested_git_repository_mode?(delta_new_file[:mode])
-          end
-        end
-
-        def submodules_params(commit, paths: [], exclude_paths: [])
-          submodules(commit, paths: paths, exclude_paths: exclude_paths).map do |submodule|
-            submodule_params(submodule).tap do |params|
-              params[:commit] = submodule.workdir_oid || params[:commit] if commit.nil?
-              if submodule.in_workdir? && !submodule.uninitialized?
-                dapp.log_info("Using local submodule repository `#{params[:path]}`!")
-                params[:type] = :local
-              end
-            end
-          end.compact
-        end
-
-        def submodules_git(commit)
-          if commit.nil?
-            git
-          else
-            super
-          end
-        end
+        def ruby2go_method(method, args_hash={})
+          res = dapp.ruby2go_git_repo(args_hash.merge("LocalGitRepo" => JSON.dump(get_ruby2go_state_hash), "method" => method))
 
-        def raise_submodule_commit_not_found!(commit)
-          raise Error::Rugged, code: :git_local_submodule_commit_not_found, data: { commit: commit, path: path }
-        end
+          raise res["error"] if res["error"]
 
-        def ignore_patch?(patch, paths: [], exclude_paths: [])
-          delta_new_file = patch.delta.new_file
-          args = [delta_new_file[:path], paths: paths, exclude_paths: exclude_paths]
-          if nested_git_repository_mode?(delta_new_file[:mode])
-            ignore_directory?(*args)
-          else
-            ignore_path?(*args)
-          end
-        end
+          self.set_ruby2go_state_hash(JSON.load(res["data"]["LocalGitRepo"]))
 
-        def nested_git_repository_mode?(mode)
-          mode == 0o040000
+          res["data"]["result"]
         end
 
-        # NOTICE: Параметры {from: nil, to: nil} можно указать только для Own repo.
-        # NOTICE: Для Remote repo такой вызов не имеет смысла и это ошибка пользователя класса Remote.
-
-        def diff(from, to, **kwargs)
-          if from.nil? and to.nil?
-            mid_commit = head_commit
-            diff_obj = super(nil, mid_commit, **kwargs)
-            diff_obj.merge! git.lookup(mid_commit).diff_workdir(**kwargs)
-            diff_obj
-          elsif to.nil?
-            git.lookup(from).diff_workdir(**kwargs)
-          else
-            super
-          end
+        def path=(path) # TODO remove
+          @path ||= Pathname(Rugged::Repository.new(path).path)
+        rescue Rugged::RepositoryError, Rugged::OSError => _e
+          raise Error::Rugged, code: :local_git_repository_does_not_exist, data: { path: path }
         end
 
         def lookup_commit(commit)
@@ -94,15 +39,6 @@ module Dapp
         rescue Rugged::OdbError, TypeError => _e
           raise Error::Rugged, code: :commit_not_found_in_local_git_repository, data: { commit: commit, path: path }
         end
-
-        protected
-
-        def git_repo_exist?(path)
-          Rugged::Repository.new(path)
-          true
-        rescue Rugged::RepositoryError, Rugged::OSError => _e
-          false
-        end
       end
     end
   end

data/lib/dapp/dimg/git_repo/own.rb

@@ -9,10 +9,6 @@ module Dapp
         def exclude_paths
           dapp.local_git_artifact_exclude_paths
         end
-
-        def submodules_git(_)
-          git
-        end
       end
     end
   end

data/lib/dapp/dimg/git_repo/remote.rb

@@ -2,7 +2,7 @@ module Dapp
   module Dimg
     module GitRepo
       class Remote < Base
-        CACHE_VERSION = 3
+        CACHE_VERSION = 4
 
         attr_reader :url
 
@@ -22,6 +22,10 @@ module Dapp
           @url = url
         end
 
+        def url
+          @url ||= remote_origin_url
+        end
+
         def ruby2go_method(method, args_hash={})
           res = dapp.ruby2go_git_repo(args_hash.merge("RemoteGitRepo" => JSON.dump(get_ruby2go_state_hash), "method" => method))
 
@@ -35,7 +39,7 @@ module Dapp
         def get_ruby2go_state_hash
           super.tap {|res|
             res["Url"] = @url.to_s
-            res["ClonePath"] = dapp.build_path("remote_git_repo", CACHE_VERSION.to_s, dapp.consistent_uniq_slugify(name), remote_origin_url_protocol).to_s # FIXME
+            res["ClonePath"] = dapp.build_path("remote_git_repo", CACHE_VERSION.to_s, dapp.consistent_uniq_slugify(name), url_protocol(url)).to_s # FIXME
             res["IsDryRun"] = dapp.dry_run?
           }
         end
@@ -45,13 +49,9 @@ module Dapp
           @url = state["Url"]
         end
 
-        def _with_lock(&blk)
-          dapp.lock("remote_git_artifact.#{name}", default_timeout: 600, &blk)
-        end
-
-        def _rugged_credentials
+        def _rugged_credentials # TODO remove
           @_rugged_credentials ||= begin
-            if remote_origin_url_protocol == :ssh
+            if url_protocol(url) == :ssh
               host_with_user = url.split(':', 2).first
               username = host_with_user.split('@', 2).reverse.last
               Rugged::Credentials::SshKeyFromAgent.new(username: username)
@@ -60,46 +60,38 @@ module Dapp
         end
 
         def path
-          Pathname(dapp.build_path("remote_git_repo", CACHE_VERSION.to_s, dapp.consistent_uniq_slugify(name), remote_origin_url_protocol).to_s)
+          Pathname(dapp.build_path("remote_git_repo", CACHE_VERSION.to_s, dapp.consistent_uniq_slugify(name), url_protocol(url)).to_s)
         end
 
         def clone_and_fetch
           return ruby2go_method("CloneAndFetch")
         end
 
-        def latest_branch_commit(branch)
-          git.ref("refs/remotes/#{branch_format(branch)}").tap do |ref|
-            raise Error::Rugged, code: :branch_not_exist_in_remote_git_repository, data: { branch: branch, url: url } if ref.nil?
-            break ref.target_id
-          end
-        end
-
-        def latest_tag_commit(tag)
-          git.tags[tag].tap do |t|
-            raise Error::Rugged, code: :tag_not_exist_in_remote_git_repository, data: { tag: tag, url: url } if t.nil?
-            break t.target_id
-          end
-        end
-
         def lookup_commit(commit)
           super
         rescue Rugged::OdbError, TypeError => _e
           raise Error::Rugged, code: :commit_not_found_in_remote_git_repository, data: { commit: commit, url: url }
         end
 
-        def raise_submodule_commit_not_found!(commit)
-          raise Error::Rugged, code: :git_remote_submodule_commit_not_found, data: { commit: commit, url: url }
-        end
-
         protected
 
-        def git
+        def git # TODO remove
           super(bare: true, credentials: _rugged_credentials)
         end
 
         private
 
-        def branch_format(name)
+        def url_protocol(url) # TODO remove
+          if (scheme = URI.parse(url).scheme).nil?
+            :noname
+          else
+            scheme.to_sym
+          end
+        rescue URI::InvalidURIError
+          :ssh
+        end
+
+        def branch_format(name) # TODO remove
           "origin/#{name.reverse.chomp('origin/'.reverse).reverse}"
         end
       end

data/lib/dapp/kube/helm/values.rb

@@ -38,8 +38,8 @@ module Dapp
           elsif ENV["CI_COMMIT_REF_NAME"]
             ci_info["branch"] = ci_info["ref"] = ENV["CI_COMMIT_REF_NAME"]
             ci_info["is_branch"] = true
-          elsif dapp.git_own_repo_exist? and dapp.git_own_repo.branch != "HEAD"
-            ci_info["branch"] = ci_info["ref"] = dapp.git_own_repo.branch
+          elsif dapp.git_own_repo_exist? and dapp.git_own_repo.head_branch_name != "HEAD"
+            ci_info["branch"] = ci_info["ref"] = dapp.git_own_repo.head_branch_name
             ci_info["is_branch"] = true
           elsif dapp.git_own_repo_exist?
             git = dapp.git_own_repo.send(:git)

data/lib/dapp/version.rb

@@ -1,4 +1,4 @@
 module Dapp
-  VERSION = "0.35.23"
+  VERSION = "0.35.24"
   BUILD_CACHE_VERSION = 31
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dapp
 version: !ruby/object:Gem::Version
-  version: 0.35.23
+  version: 0.35.24
 platform: ruby
 authors:
 - Dmitry Stolyarov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-17 00:00:00.000000000 Z
+date: 2018-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mixlib-shellout