commit_service.rb 7.53 KB
Newer Older
1 2
module Gitlab
  module GitalyClient
Andrew Newdigate's avatar
Andrew Newdigate committed
3
    class CommitService
4 5 6 7
      # The ID of empty tree.
      # See http://stackoverflow.com/a/40884093/1856239 and https://github.com/git/git/blob/3ad8b5bf26362ac67c9020bf8c30eee54a84f56d/cache.h#L1011-L1012
      EMPTY_TREE_ID = '4b825dc642cb6eb9a060e54bf8d69288fbee4904'.freeze

8 9
      def initialize(repository)
        @gitaly_repo = repository.gitaly_repository
10
        @repository = repository
11 12
      end

13 14 15 16 17 18 19 20 21 22 23 24
      def ls_files(revision)
        request = Gitaly::ListFilesRequest.new(
          repository: @gitaly_repo,
          revision: GitalyClient.encode(revision)
        )

        response = GitalyClient.call(@repository.storage, :commit_service, :list_files, request)
        response.flat_map do |msg|
          msg.paths.map { |d| d.dup.force_encoding(Encoding::UTF_8) }
        end
      end

25 26 27 28 29 30 31
      def is_ancestor(ancestor_id, child_id)
        request = Gitaly::CommitIsAncestorRequest.new(
          repository: @gitaly_repo,
          ancestor_id: ancestor_id,
          child_id: child_id
        )

Andrew Newdigate's avatar
Andrew Newdigate committed
32
        GitalyClient.call(@repository.storage, :commit_service, :commit_is_ancestor, request).value
33 34 35 36 37
      end

      def diff_from_parent(commit, options = {})
        request_params = commit_diff_request_params(commit, options)
        request_params[:ignore_whitespace_change] = options.fetch(:ignore_whitespace_change, false)
38 39 40 41
        request_params[:enforce_limits] = options.fetch(:limits, true)
        request_params[:collapse_diffs] = request_params[:enforce_limits] || !options.fetch(:expanded, true)
        request_params.merge!(Gitlab::Git::DiffCollection.collection_limits(options).to_h)

42
        request = Gitaly::CommitDiffRequest.new(request_params)
Andrew Newdigate's avatar
Andrew Newdigate committed
43
        response = GitalyClient.call(@repository.storage, :diff_service, :commit_diff, request)
44
        GitalyClient::DiffStitcher.new(response)
45 46
      end

47
      def commit_deltas(commit)
48
        request = Gitaly::CommitDeltaRequest.new(commit_diff_request_params(commit))
Andrew Newdigate's avatar
Andrew Newdigate committed
49
        response = GitalyClient.call(@repository.storage, :diff_service, :commit_delta, request)
50 51

        response.flat_map { |msg| msg.deltas }
52
      end
53

54 55 56 57
      def tree_entry(ref, path, limit = nil)
        request = Gitaly::TreeEntryRequest.new(
          repository: @gitaly_repo,
          revision: ref,
58
          path: GitalyClient.encode(path),
59 60 61
          limit: limit.to_i
        )

Andrew Newdigate's avatar
Andrew Newdigate committed
62
        response = GitalyClient.call(@repository.storage, :commit_service, :tree_entry, request)
63

Jacob Vosmaer's avatar
Jacob Vosmaer committed
64 65 66 67 68 69 70 71 72 73
        entry = nil
        data = ''
        response.each do |msg|
          if entry.nil?
            entry = msg

            break unless entry.type == :BLOB
          end

          data << msg.data
74
        end
Jacob Vosmaer's avatar
Jacob Vosmaer committed
75
        entry.data = data
76

Jacob Vosmaer's avatar
Jacob Vosmaer committed
77
        entry unless entry.oid.blank?
78 79
      end

80 81 82
      def tree_entries(repository, revision, path)
        request = Gitaly::GetTreeEntriesRequest.new(
          repository: @gitaly_repo,
83 84
          revision: GitalyClient.encode(revision),
          path: path.present? ? GitalyClient.encode(path) : '.'
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
        )

        response = GitalyClient.call(@repository.storage, :commit_service, :get_tree_entries, request)

        response.flat_map do |message|
          message.entries.map do |gitaly_tree_entry|
            entry_path = gitaly_tree_entry.path.dup
            Gitlab::Git::Tree.new(
              id: gitaly_tree_entry.oid,
              root_id: gitaly_tree_entry.root_oid,
              type: gitaly_tree_entry.type.downcase,
              mode: gitaly_tree_entry.mode.to_s(8),
              name: File.basename(entry_path),
              path: entry_path,
              commit_id: gitaly_tree_entry.commit_oid
            )
          end
        end
      end
104

105
      def commit_count(ref, options = {})
106 107 108 109
        request = Gitaly::CountCommitsRequest.new(
          repository: @gitaly_repo,
          revision: ref
        )
110 111 112
        request.after = Google::Protobuf::Timestamp.new(seconds: options[:after].to_i) if options[:after].present?
        request.before = Google::Protobuf::Timestamp.new(seconds: options[:before].to_i) if options[:before].present?
        request.path = options[:path] if options[:path].present?
113 114 115 116

        GitalyClient.call(@repository.storage, :commit_service, :count_commits, request).count
      end

117 118 119
      def last_commit_for_path(revision, path)
        request = Gitaly::LastCommitForPathRequest.new(
          repository: @gitaly_repo,
120 121
          revision: GitalyClient.encode(revision),
          path: GitalyClient.encode(path.to_s)
122 123 124 125 126
        )

        gitaly_commit = GitalyClient.call(@repository.storage, :commit_service, :last_commit_for_path, request).commit
        return unless gitaly_commit

127
        Gitlab::Git::Commit.new(@repository, gitaly_commit)
128 129
      end

130 131 132 133 134 135 136 137 138 139 140
      def between(from, to)
        request = Gitaly::CommitsBetweenRequest.new(
          repository: @gitaly_repo,
          from: from,
          to: to
        )

        response = GitalyClient.call(@repository.storage, :commit_service, :commits_between, request)
        consume_commits_response(response)
      end

141 142 143 144 145 146 147 148 149 150 151 152 153
      def find_all_commits(opts = {})
        request = Gitaly::FindAllCommitsRequest.new(
          repository: @gitaly_repo,
          revision: opts[:ref].to_s,
          max_count: opts[:max_count].to_i,
          skip: opts[:skip].to_i
        )
        request.order = opts[:order].upcase if opts[:order].present?

        response = GitalyClient.call(@repository.storage, :commit_service, :find_all_commits, request)
        consume_commits_response(response)
      end

154 155 156 157 158 159 160 161 162 163 164 165 166 167
      def commits_by_message(query, revision: '', path: '', limit: 1000, offset: 0)
        request = Gitaly::CommitsByMessageRequest.new(
          repository: @gitaly_repo,
          query: query,
          revision: revision.to_s.force_encoding(Encoding::ASCII_8BIT),
          path: path.to_s.force_encoding(Encoding::ASCII_8BIT),
          limit: limit.to_i,
          offset: offset.to_i
        )

        response = GitalyClient.call(@repository.storage, :commit_service, :commits_by_message, request)
        consume_commits_response(response)
      end

168 169 170 171 172 173 174
      def languages(ref = nil)
        request = Gitaly::CommitLanguagesRequest.new(repository: @gitaly_repo, revision: ref || '')
        response = GitalyClient.call(@repository.storage, :commit_service, :commit_languages, request)

        response.languages.map { |l| { value: l.share.round(2), label: l.name, color: l.color, highlight: l.color } }
      end

175 176 177 178 179 180 181 182 183 184 185
      def raw_blame(revision, path)
        request = Gitaly::RawBlameRequest.new(
          repository: @gitaly_repo,
          revision: revision,
          path: path
        )

        response = GitalyClient.call(@repository.storage, :commit_service, :raw_blame, request)
        response.reduce("") { |memo, msg| memo << msg.data }
      end

186 187 188 189 190 191 192 193 194 195 196
      def find_commit(revision)
        request = Gitaly::FindCommitRequest.new(
          repository: @gitaly_repo,
          revision: GitalyClient.encode(revision)
        )

        response = GitalyClient.call(@repository.storage, :commit_service, :find_commit, request)

        response.commit
      end

197 198 199
      private

      def commit_diff_request_params(commit, options = {})
200
        parent_id = commit.parent_ids.first || EMPTY_TREE_ID
201 202 203 204 205 206 207 208

        {
          repository: @gitaly_repo,
          left_commit_id: parent_id,
          right_commit_id: commit.id,
          paths: options.fetch(:paths, [])
        }
      end
209 210

      def consume_commits_response(response)
211 212
        response.flat_map do |message|
          message.commits.map do |gitaly_commit|
213
            Gitlab::Git::Commit.new(@repository, gitaly_commit)
214 215
          end
        end
216
      end
217 218 219
    end
  end
end