Merge branch 'update-gitlab-git' into 'master'

Update vendored gitlab_git to 6f045671e665e42c7

See merge request gitlab-org/gitaly!446

12 files changed, 395 insertions, 49 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 198d59ddc..9fa91250d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,8 @@
 
 UNRELEASED
 
+- Update vendored gitlab_git to 6f045671e665e42c7
+  https://gitlab.com/gitlab-org/gitaly/merge_requests/446
 - Implement WikiGetPageVersions RPC
   https://gitlab.com/gitlab-org/gitaly/merge_requests/430
 
diff --git a/ruby/lib/gitlab/git.rb b/ruby/lib/gitlab/git.rb
index 1c8fccf09..ab17d5341 100644
--- a/ruby/lib/gitlab/git.rb
+++ b/ruby/lib/gitlab/git.rb
@@ -22,6 +22,7 @@ require_relative File.join(vendor_gitlab_git, 'lib/gitlab/encoding_helper.rb')
 require_relative File.join(vendor_gitlab_git, 'lib/gitlab/git.rb')
 require_relative File.join(vendor_gitlab_git, 'lib/gitlab/git/popen.rb')
 require_relative File.join(vendor_gitlab_git, 'lib/gitlab/git/ref.rb')
+require_relative File.join(vendor_gitlab_git, 'lib/gitlab/git/repository_mirroring.rb')
 
 # Require all .rb files we can find in the vendored gitlab/git directory
 dir = File.expand_path(File.join('..', vendor_gitlab_git, 'lib/gitlab/'), __FILE__)
diff --git a/ruby/vendor/gitlab_git/REVISION b/ruby/vendor/gitlab_git/REVISION
index 80906ffd1..b8b33bb61 100644
--- a/ruby/vendor/gitlab_git/REVISION
+++ b/ruby/vendor/gitlab_git/REVISION
@@ -1 +1 @@
-b3ba3996e0bd329eaa574ff53c69673efaca6eef
+6f045671e665e42c7f354541e6804dda3c03438f
diff --git a/ruby/vendor/gitlab_git/lib/gitlab/git/blob.rb b/ruby/vendor/gitlab_git/lib/gitlab/git/blob.rb
index a4336face..cc6c7609e 100644
--- a/ruby/vendor/gitlab_git/lib/gitlab/git/blob.rb
+++ b/ruby/vendor/gitlab_git/lib/gitlab/git/blob.rb
@@ -12,6 +12,12 @@ module Gitlab
       # blob data should use load_all_data!.
       MAX_DATA_DISPLAY_SIZE = 10.megabytes
 
+      # These limits are used as a heuristic to ignore files which can't be LFS
+      # pointers. The format of these is described in
+      # https://github.com/git-lfs/git-lfs/blob/master/docs/spec.md#the-pointer
+      LFS_POINTER_MIN_SIZE = 120.bytes
+      LFS_POINTER_MAX_SIZE = 200.bytes
+
       attr_accessor :name, :path, :size, :data, :mode, :id, :commit_id, :loaded_size, :binary
 
       class << self
@@ -30,16 +36,7 @@ module Gitlab
             if is_enabled
               Gitlab::GitalyClient::BlobService.new(repository).get_blob(oid: sha, limit: MAX_DATA_DISPLAY_SIZE)
             else
-              blob = repository.lookup(sha)
-
-              next unless blob.is_a?(Rugged::Blob)
-
-              new(
-                id: blob.oid,
-                size: blob.size,
-                data: blob.content(MAX_DATA_DISPLAY_SIZE),
-                binary: blob.binary?
-              )
+              rugged_raw(repository, sha, limit: MAX_DATA_DISPLAY_SIZE)
             end
           end
         end
@@ -59,10 +56,25 @@ module Gitlab
           end
         end
 
+        # Find LFS blobs given an array of sha ids
+        # Returns array of Gitlab::Git::Blob
+        # Does not guarantee blob data will be set
+        def batch_lfs_pointers(repository, blob_ids)
+          blob_ids.lazy
+                  .select { |sha| possible_lfs_blob?(repository, sha) }
+                  .map { |sha| rugged_raw(repository, sha, limit: LFS_POINTER_MAX_SIZE) }
+                  .select(&:lfs_pointer?)
+                  .force
+        end
+
         def binary?(data)
           EncodingHelper.detect_libgit2_binary?(data)
         end
 
+        def size_could_be_lfs?(size)
+          size.between?(LFS_POINTER_MIN_SIZE, LFS_POINTER_MAX_SIZE)
+        end
+
         private
 
         # Recursive search of blob id by path
@@ -167,6 +179,29 @@ module Gitlab
             end
           end
         end
+
+        def rugged_raw(repository, sha, limit:)
+          blob = repository.lookup(sha)
+
+          return unless blob.is_a?(Rugged::Blob)
+
+          new(
+            id: blob.oid,
+            size: blob.size,
+            data: blob.content(limit),
+            binary: blob.binary?
+          )
+        end
+
+        # Efficient lookup to determine if object size
+        # and type make it a possible LFS blob without loading
+        # blob content into memory with repository.lookup(sha)
+        def possible_lfs_blob?(repository, sha)
+          object_header = repository.rugged.read_header(sha)
+
+          object_header[:type] == :blob &&
+            size_could_be_lfs?(object_header[:len])
+        end
       end
 
       def initialize(options)
@@ -226,7 +261,7 @@ module Gitlab
       # size
       # see https://github.com/github/git-lfs/blob/v1.1.0/docs/spec.md#the-pointer
       def lfs_pointer?
-        has_lfs_version_key? && lfs_oid.present? && lfs_size.present?
+        self.class.size_could_be_lfs?(size) && has_lfs_version_key? && lfs_oid.present? && lfs_size.present?
       end
 
       def lfs_oid
diff --git a/ruby/vendor/gitlab_git/lib/gitlab/git/branch.rb b/ruby/vendor/gitlab_git/lib/gitlab/git/branch.rb
index c53882787..3487e0993 100644
--- a/ruby/vendor/gitlab_git/lib/gitlab/git/branch.rb
+++ b/ruby/vendor/gitlab_git/lib/gitlab/git/branch.rb
@@ -3,6 +3,14 @@
 module Gitlab
   module Git
     class Branch < Ref
+      def self.find(repo, branch_name)
+        if branch_name.is_a?(Gitlab::Git::Branch)
+          branch_name
+        else
+          repo.find_branch(branch_name)
+        end
+      end
+
       def initialize(repository, name, target, target_commit)
         super(repository, name, target, target_commit)
       end
diff --git a/ruby/vendor/gitlab_git/lib/gitlab/git/commit.rb b/ruby/vendor/gitlab_git/lib/gitlab/git/commit.rb
index 1957c254c..d55188144 100644
--- a/ruby/vendor/gitlab_git/lib/gitlab/git/commit.rb
+++ b/ruby/vendor/gitlab_git/lib/gitlab/git/commit.rb
@@ -72,7 +72,8 @@ module Gitlab
 
           decorate(repo, commit) if commit
         rescue Rugged::ReferenceError, Rugged::InvalidError, Rugged::ObjectError,
-               Gitlab::Git::CommandError, Gitlab::Git::Repository::NoRepository
+               Gitlab::Git::CommandError, Gitlab::Git::Repository::NoRepository,
+               Rugged::OdbError, Rugged::TreeError, ArgumentError
           nil
         end
 
diff --git a/ruby/vendor/gitlab_git/lib/gitlab/git/lfs_changes.rb b/ruby/vendor/gitlab_git/lib/gitlab/git/lfs_changes.rb
new file mode 100644
index 000000000..732dd5d99
--- /dev/null
+++ b/ruby/vendor/gitlab_git/lib/gitlab/git/lfs_changes.rb
@@ -0,0 +1,33 @@
+module Gitlab
+  module Git
+    class LfsChanges
+      def initialize(repository, newrev)
+        @repository = repository
+        @newrev = newrev
+      end
+
+      def new_pointers(object_limit: nil, not_in: nil)
+        @new_pointers ||= begin
+          rev_list.new_objects(not_in: not_in, require_path: true) do |object_ids|
+            object_ids = object_ids.take(object_limit) if object_limit
+
+            Gitlab::Git::Blob.batch_lfs_pointers(@repository, object_ids)
+          end
+        end
+      end
+
+      def all_pointers
+        rev_list.all_objects(require_path: true) do |object_ids|
+          Gitlab::Git::Blob.batch_lfs_pointers(@repository, object_ids)
+        end
+      end
+
+      private
+
+      def rev_list
+        ::Gitlab::Git::RevList.new(path_to_repo: @repository.path_to_repo,
+                                   newrev: @newrev)
+      end
+    end
+  end
+end
diff --git a/ruby/vendor/gitlab_git/lib/gitlab/git/popen.rb b/ruby/vendor/gitlab_git/lib/gitlab/git/popen.rb
index b45da6020..d41fe78da 100644
--- a/ruby/vendor/gitlab_git/lib/gitlab/git/popen.rb
+++ b/ruby/vendor/gitlab_git/lib/gitlab/git/popen.rb
@@ -7,7 +7,7 @@ module Gitlab
     module Popen
       FAST_GIT_PROCESS_TIMEOUT = 15.seconds
 
-      def popen(cmd, path, vars = {})
+      def popen(cmd, path, vars = {}, lazy_block: nil)
         unless cmd.is_a?(Array)
           raise "System commands must be given as an array of strings"
         end
@@ -22,7 +22,12 @@ module Gitlab
           yield(stdin) if block_given?
           stdin.close
 
-          @cmd_output << stdout.read
+          if lazy_block
+            return lazy_block.call(stdout.lazy)
+          else
+            @cmd_output << stdout.read
+          end
+
           @cmd_output << stderr.read
           @cmd_status = wait_thr.value.exitstatus
         end
diff --git a/ruby/vendor/gitlab_git/lib/gitlab/git/repository.rb b/ruby/vendor/gitlab_git/lib/gitlab/git/repository.rb
index 408616d17..d236e1b03 100644
--- a/ruby/vendor/gitlab_git/lib/gitlab/git/repository.rb
+++ b/ruby/vendor/gitlab_git/lib/gitlab/git/repository.rb
@@ -6,6 +6,7 @@ require "rubygems/package"
 module Gitlab
   module Git
     class Repository
+      include Gitlab::Git::RepositoryMirroring
       include Gitlab::Git::Popen
 
       ALLOWED_OBJECT_DIRECTORIES_VARIABLES = %w[
@@ -290,6 +291,14 @@ module Gitlab
         end
       end
 
+      def batch_existence(object_ids, existing: true)
+        filter_method = existing ? :select : :reject
+
+        object_ids.public_send(filter_method) do |oid| # rubocop:disable GitlabSecurity/PublicSend
+          rugged.exists?(oid)
+        end
+      end
+
       # Returns an Array of branch and tag names
       def ref_names
         branch_names + tag_names
@@ -511,6 +520,10 @@ module Gitlab
         gitaly_commit_client.ancestor?(from, to)
       end
 
+      def merged_branch_names(branch_names = [])
+        Set.new(git_merged_branch_names(branch_names))
+      end
+
       # Return an array of Diff objects that represent the diff
       # between +from+ and +to+.  See Diff::filter_diff_options for the allowed
       # diff options.  The +options+ hash can also include :break_rewrites to
@@ -746,13 +759,13 @@ module Gitlab
       end
 
       def ff_merge(user, source_sha, target_branch)
-        OperationService.new(user, self).with_branch(target_branch) do |our_commit|
-          raise ArgumentError, 'Invalid merge target' unless our_commit
-
-          source_sha
+        gitaly_migrate(:operation_user_ff_branch) do |is_enabled|
+          if is_enabled
+            gitaly_ff_merge(user, source_sha, target_branch)
+          else
+            rugged_ff_merge(user, source_sha, target_branch)
+          end
         end
-      rescue Rugged::ReferenceError
-        raise ArgumentError, 'Invalid merge source'
       end
 
       def revert(user:, commit:, branch_name:, message:, start_branch_name:, start_repository:)
@@ -886,16 +899,30 @@ module Gitlab
         end
       end
 
-      # Delete the specified remote from this repository.
-      def remote_delete(remote_name)
+      def add_remote(remote_name, url)
+        rugged.remotes.create(remote_name, url)
+      rescue Rugged::ConfigError
+        remote_update(remote_name, url: url)
+      end
+
+      def remove_remote(remote_name)
+        # When a remote is deleted all its remote refs are deleted too, but in
+        # the case of mirrors we map its refs (that would usualy go under
+        # [remote_name]/) to the top level namespace. We clean the mapping so
+        # those don't get deleted.
+        if rugged.config["remote.#{remote_name}.mirror"]
+          rugged.config.delete("remote.#{remote_name}.fetch")
+        end
+
         rugged.remotes.delete(remote_name)
-        nil
+        true
+      rescue Rugged::ConfigError
+        false
       end
 
-      # Add a new remote to this repository.
-      def remote_add(remote_name, url)
-        rugged.remotes.create(remote_name, url)
-        nil
+      # Returns true if a remote exists.
+      def remote_exists?(name)
+        rugged.remotes[name].present?
       end
 
       # Update the specified remote using the values in the +options+ hash
@@ -1022,7 +1049,7 @@ module Gitlab
         delete_refs(tmp_ref) if tmp_ref
       end
 
-      def fetch_source_branch(source_repository, source_branch, local_ref)
+      def fetch_source_branch!(source_repository, source_branch, local_ref)
         with_repo_branch_commit(source_repository, source_branch) do |commit|
           if commit
             write_ref(local_ref, commit.sha)
@@ -1165,10 +1192,10 @@ module Gitlab
         Gitlab::GitalyClient.migrate(method, status: status, &block)
       rescue GRPC::NotFound => e
         raise NoRepository.new(e)
-      rescue GRPC::BadStatus => e
-        raise CommandError.new(e)
       rescue GRPC::InvalidArgument => e
         raise ArgumentError.new(e)
+      rescue GRPC::BadStatus => e
+        raise CommandError.new(e)
       end
 
       private
@@ -1190,6 +1217,13 @@ module Gitlab
         sort_branches(branches, sort_by)
       end
 
+      def git_merged_branch_names(branch_names = [])
+        lines = run_git(['branch', '--merged', root_ref] + branch_names)
+          .first.lines
+
+        lines.map(&:strip)
+      end
+
       def log_using_shell?(options)
         options[:path].present? ||
           options[:disable_walk] ||
@@ -1603,6 +1637,22 @@ module Gitlab
 
         run_git(args, env: env)
       end
+
+      def gitaly_ff_merge(user, source_sha, target_branch)
+        gitaly_operations_client.user_ff_branch(user, source_sha, target_branch)
+      rescue GRPC::FailedPrecondition => e
+        raise CommitError, e
+      end
+
+      def rugged_ff_merge(user, source_sha, target_branch)
+        OperationService.new(user, self).with_branch(target_branch) do |our_commit|
+          raise ArgumentError, 'Invalid merge target' unless our_commit
+
+          source_sha
+        end
+      rescue Rugged::ReferenceError
+        raise ArgumentError, 'Invalid merge source'
+      end
     end
   end
 end
diff --git a/ruby/vendor/gitlab_git/lib/gitlab/git/repository_mirroring.rb b/ruby/vendor/gitlab_git/lib/gitlab/git/repository_mirroring.rb
new file mode 100644
index 000000000..637e7a065
--- /dev/null
+++ b/ruby/vendor/gitlab_git/lib/gitlab/git/repository_mirroring.rb
@@ -0,0 +1,95 @@
+module Gitlab
+  module Git
+    module RepositoryMirroring
+      IMPORT_HEAD_REFS = '+refs/heads/*:refs/heads/*'.freeze
+      IMPORT_TAG_REFS = '+refs/tags/*:refs/tags/*'.freeze
+      MIRROR_REMOTE = 'mirror'.freeze
+
+      RemoteError = Class.new(StandardError)
+
+      def set_remote_as_mirror(remote_name)
+        # This is used to define repository as equivalent as "git clone --mirror"
+        rugged.config["remote.#{remote_name}.fetch"] = 'refs/*:refs/*'
+        rugged.config["remote.#{remote_name}.mirror"] = true
+        rugged.config["remote.#{remote_name}.prune"] = true
+      end
+
+      def set_import_remote_as_mirror(remote_name)
+        # Add first fetch with Rugged so it does not create its own.
+        rugged.config["remote.#{remote_name}.fetch"] = IMPORT_HEAD_REFS
+
+        add_remote_fetch_config(remote_name, IMPORT_TAG_REFS)
+
+        rugged.config["remote.#{remote_name}.mirror"] = true
+        rugged.config["remote.#{remote_name}.prune"] = true
+      end
+
+      def add_remote_fetch_config(remote_name, refspec)
+        run_git(%W[config --add remote.#{remote_name}.fetch #{refspec}])
+      end
+
+      def fetch_mirror(url)
+        add_remote(MIRROR_REMOTE, url)
+        set_remote_as_mirror(MIRROR_REMOTE)
+        fetch(MIRROR_REMOTE)
+        remove_remote(MIRROR_REMOTE)
+      end
+
+      def remote_tags(remote)
+        # Each line has this format: "dc872e9fa6963f8f03da6c8f6f264d0845d6b092\trefs/tags/v1.10.0\n"
+        # We want to convert it to: [{ 'v1.10.0' => 'dc872e9fa6963f8f03da6c8f6f264d0845d6b092' }, ...]
+        list_remote_tags(remote).map do |line|
+          target, path = line.strip.split("\t")
+
+          # When the remote repo does not have tags.
+          if target.nil? || path.nil?
+            Rails.logger.info "Empty or invalid list of tags for remote: #{remote}. Output: #{output}"
+            return []
+          end
+
+          name = path.split('/', 3).last
+          # We're only interested in tag references
+          # See: http://stackoverflow.com/questions/15472107/when-listing-git-ls-remote-why-theres-after-the-tag-name
+          next if name =~ /\^\{\}\Z/
+
+          target_commit = Gitlab::Git::Commit.find(self, target)
+          Gitlab::Git::Tag.new(self, name, target, target_commit)
+        end.compact
+      end
+
+      def remote_branches(remote_name)
+        branches = []
+
+        rugged.references.each("refs/remotes/#{remote_name}/*").map do |ref|
+          name = ref.name.sub(/\Arefs\/remotes\/#{remote_name}\//, '')
+
+          begin
+            target_commit = Gitlab::Git::Commit.find(self, ref.target)
+            branches << Gitlab::Git::Branch.new(self, name, ref.target, target_commit)
+          rescue Rugged::ReferenceError
+            # Omit invalid branch
+          end
+        end
+
+        branches
+      end
+
+      private
+
+      def list_remote_tags(remote)
+        tag_list, exit_code, error = nil
+        cmd = %W(#{Gitlab.config.git.bin_path} --git-dir=#{full_path} ls-remote --tags #{remote})
+
+        Open3.popen3(*cmd) do |stdin, stdout, stderr, wait_thr|
+          tag_list  = stdout.read
+          error     = stderr.read
+          exit_code = wait_thr.value.exitstatus
+        end
+
+        raise RemoteError, error unless exit_code.zero?
+
+        tag_list.split('\n')
+      end
+    end
+  end
+end
diff --git a/ruby/vendor/gitlab_git/lib/gitlab/git/rev_list.rb b/ruby/vendor/gitlab_git/lib/gitlab/git/rev_list.rb
index 60b2a4ec4..4974205b8 100644
--- a/ruby/vendor/gitlab_git/lib/gitlab/git/rev_list.rb
+++ b/ruby/vendor/gitlab_git/lib/gitlab/git/rev_list.rb
@@ -13,11 +13,32 @@ module Gitlab
         @path_to_repo = path_to_repo
       end
 
-      # This method returns an array of new references
+      # This method returns an array of new commit references
       def new_refs
         execute([*base_args, newrev, '--not', '--all'])
       end
 
+      # Finds newly added objects
+      # Returns an array of shas
+      #
+      # Can skip objects which do not have a path using required_path: true
+      # This skips commit objects and root trees, which might not be needed when
+      # looking for blobs
+      #
+      # When given a block it will yield objects as a lazy enumerator so
+      # the caller can limit work done instead of processing megabytes of data
+      def new_objects(require_path: nil, not_in: nil, &lazy_block)
+        args = [*base_args, newrev, *not_in_refs(not_in), '--objects']
+
+        get_objects(args, require_path: require_path, &lazy_block)
+      end
+
+      def all_objects(require_path: nil, &lazy_block)
+        args = [*base_args, '--all', '--objects']
+
+        get_objects(args, require_path: require_path, &lazy_block)
+      end
+
       # This methods returns an array of missed references
       #
       # Should become obsolete after https://gitlab.com/gitlab-org/gitaly/issues/348.
@@ -27,6 +48,13 @@ module Gitlab
 
       private
 
+      def not_in_refs(references)
+        return ['--not', '--all'] unless references
+        return [] if references.empty?
+
+        references.prepend('--not')
+      end
+
       def execute(args)
         output, status = popen(args, nil, Gitlab::Git::Env.to_env_hash)
 
@@ -37,6 +65,10 @@ module Gitlab
         output.split("\n")
       end
 
+      def lazy_execute(args, &lazy_block)
+        popen(args, nil, Gitlab::Git::Env.to_env_hash, lazy_block: lazy_block)
+      end
+
       def base_args
         [
           Gitlab.config.git.bin_path,
@@ -44,6 +76,30 @@ module Gitlab
           'rev-list'
         ]
       end
+
+      def get_objects(args, require_path: nil)
+        if block_given?
+          lazy_execute(args) do |lazy_output|
+            objects = objects_from_output(lazy_output, require_path: require_path)
+
+            yield(objects)
+          end
+        else
+          object_output = execute(args)
+
+          objects_from_output(object_output, require_path: require_path)
+        end
+      end
+
+      def objects_from_output(object_output, require_path: nil)
+        object_output.map do |output_line|
+          sha, path = output_line.split(' ', 2)
+
+          next if require_path && path.blank?
+
+          sha
+        end.reject(&:nil?)
+      end
     end
   end
 end
diff --git a/ruby/vendor/gitlab_git/lib/gitlab/git/wiki.rb b/ruby/vendor/gitlab_git/lib/gitlab/git/wiki.rb
index e7b2f52a5..fe901d049 100644
--- a/ruby/vendor/gitlab_git/lib/gitlab/git/wiki.rb
+++ b/ruby/vendor/gitlab_git/lib/gitlab/git/wiki.rb
@@ -8,6 +8,9 @@ module Gitlab
           { name: name, email: email, message: message }
         end
       end
+      PageBlob = Struct.new(:name)
+
+      attr_reader :repository
 
       def self.default_ref
         'master'
@@ -34,10 +37,14 @@ module Gitlab
       end
 
       def delete_page(page_path, commit_details)
-        assert_type!(commit_details, CommitDetails)
-
-        gollum_wiki.delete_page(gollum_page_by_path(page_path), commit_details.to_h)
-        nil
+        @repository.gitaly_migrate(:wiki_delete_page) do |is_enabled|
+          if is_enabled
+            gitaly_delete_page(page_path, commit_details)
+            gollum_wiki.clear_cache
+          else
+            gollum_delete_page(page_path, commit_details)
+          end
+        end
       end
 
       def update_page(page_path, title, format, content, commit_details)
@@ -53,22 +60,23 @@ module Gitlab
       end
 
       def page(title:, version: nil, dir: nil)
-        if version
-          version = Gitlab::Git::Commit.find(@repository, version).id
+        @repository.gitaly_migrate(:wiki_find_page) do |is_enabled|
+          if is_enabled
+            gitaly_find_page(title: title, version: version, dir: dir)
+          else
+            gollum_find_page(title: title, version: version, dir: dir)
+          end
         end
-
-        gollum_page = gollum_wiki.page(title, version, dir)
-        return unless gollum_page
-
-        new_page(gollum_page)
       end
 
       def file(name, version)
-        version ||= self.class.default_ref
-        gollum_file = gollum_wiki.file(name, version)
-        return unless gollum_file
-
-        Gitlab::Git::WikiFile.new(gollum_file)
+        @repository.gitaly_migrate(:wiki_find_file) do |is_enabled|
+          if is_enabled
+            gitaly_find_file(name, version)
+          else
+            gollum_find_file(name, version)
+          end
+        end
       end
 
       def page_versions(page_path)
@@ -80,7 +88,15 @@ module Gitlab
       end
 
       def preview_slug(title, format)
-        gollum_wiki.preview_page(title, '', format).url_path
+        # Adapted from gollum gem (Gollum::Wiki#preview_page) to avoid
+        # using Rugged through a Gollum::Wiki instance
+        page_class = Gollum::Page
+        page = page_class.new(nil)
+        ext = page_class.format_to_ext(format.to_sym)
+        name = page_class.cname(title) + '.' + ext
+        blob = PageBlob.new(name)
+        page.populate(blob)
+        page.url_path
       end
 
       private
@@ -126,9 +142,53 @@ module Gitlab
         raise Gitlab::Git::Wiki::DuplicatePageError, e.message
       end
 
+      def gollum_delete_page(page_path, commit_details)
+        assert_type!(commit_details, CommitDetails)
+
+        gollum_wiki.delete_page(gollum_page_by_path(page_path), commit_details.to_h)
+        nil
+      end
+
+      def gollum_find_page(title:, version: nil, dir: nil)
+        if version
+          version = Gitlab::Git::Commit.find(@repository, version).id
+        end
+
+        gollum_page = gollum_wiki.page(title, version, dir)
+        return unless gollum_page
+
+        new_page(gollum_page)
+      end
+
+      def gollum_find_file(name, version)
+        version ||= self.class.default_ref
+        gollum_file = gollum_wiki.file(name, version)
+        return unless gollum_file
+
+        Gitlab::Git::WikiFile.new(gollum_file)
+      end
+
       def gitaly_write_page(name, format, content, commit_details)
         gitaly_wiki_client.write_page(name, format, content, commit_details)
       end
+
+      def gitaly_delete_page(page_path, commit_details)
+        gitaly_wiki_client.delete_page(page_path, commit_details)
+      end
+
+      def gitaly_find_page(title:, version: nil, dir: nil)
+        wiki_page, version = gitaly_wiki_client.find_page(title: title, version: version, dir: dir)
+        return unless wiki_page
+
+        Gitlab::Git::WikiPage.new(wiki_page, version)
+      end
+
+      def gitaly_find_file(name, version)
+        wiki_file = gitaly_wiki_client.find_file(name, version)
+        return unless wiki_file
+
+        Gitlab::Git::WikiFile.new(wiki_file)
+      end
     end
   end
 end