Merge branch 'sh-log-project-name-with-gitaly-ee' into 'master'

Send project name with Gitaly repository requests (EE port)

Closes gitaly#1394

See merge request gitlab-org/gitlab-ee!8666

Gemfile

@@ -437,7 +437,7 @@ group :ed25519 do
 end
 
 # Gitaly GRPC client
-gem 'gitaly-proto', '~> 1.5.0', require: 'gitaly'
+gem 'gitaly-proto', '~> 1.10.0', require: 'gitaly'
 gem 'grpc', '~> 1.15.0'
 
 gem 'google-protobuf', '~> 3.6'

Gemfile.lock

@@ -302,7 +302,7 @@ GEM
       gettext_i18n_rails (>= 0.7.1)
       po_to_json (>= 1.0.0)
       rails (>= 3.2.0)
-    gitaly-proto (1.5.0)
+    gitaly-proto (1.10.0)
       grpc (~> 1.0)
     github-markup (1.7.0)
     gitlab-default_value_for (3.1.1)
@@ -1055,7 +1055,7 @@ DEPENDENCIES
   gettext (~> 3.2.2)
   gettext_i18n_rails (~> 1.8.0)
   gettext_i18n_rails_js (~> 1.3)
-  gitaly-proto (~> 1.5.0)
+  gitaly-proto (~> 1.10.0)
   github-markup (~> 1.7.0)
   gitlab-default_value_for (~> 3.1.1)
   gitlab-license (~> 1.0)

app/models/pool_repository.rb

@@ -96,7 +96,9 @@ class PoolRepository < ActiveRecord::Base
     @object_pool ||= Gitlab::Git::ObjectPool.new(
       shard.name,
       disk_path + '.git',
-      source_project.repository.raw)
+      source_project.repository.raw,
+      source_project.full_path
+    )
   end
 
   def inspect

app/models/project.rb

@@ -1288,7 +1288,7 @@ class Project < ActiveRecord::Base
     # Forked import is handled asynchronously
     return if forked? && !force
 
-    if gitlab_shell.create_repository(repository_storage, disk_path)
+    if gitlab_shell.create_project_repository(self)
       repository.after_create
       true
     else

app/models/project_wiki.rb

@@ -60,7 +60,7 @@ class ProjectWiki
   def wiki
     @wiki ||= begin
       gl_repository = Gitlab::GlRepository.gl_repository(project, true)
-      raw_repository = Gitlab::Git::Repository.new(project.repository_storage, disk_path + '.git', gl_repository)
+      raw_repository = Gitlab::Git::Repository.new(project.repository_storage, disk_path + '.git', gl_repository, full_path)
 
       create_repo!(raw_repository) unless raw_repository.exists?
 
@@ -175,7 +175,7 @@ class ProjectWiki
   private
 
   def create_repo!(raw_repository)
-    gitlab_shell.create_repository(project.repository_storage, disk_path)
+    gitlab_shell.create_wiki_repository(project)
 
     raise CouldNotCreateWikiError unless raw_repository.exists?
 

app/models/repository.rb

@@ -1104,7 +1104,10 @@ class Repository
   end
 
   def initialize_raw_repository
-    Gitlab::Git::Repository.new(project.repository_storage, disk_path + '.git', Gitlab::GlRepository.gl_repository(project, is_wiki))
+    Gitlab::Git::Repository.new(project.repository_storage,
+                                disk_path + '.git',
+                                Gitlab::GlRepository.gl_repository(project, is_wiki),
+                                project.full_path)
   end
 end
 

app/services/projects/import_service.rb

@@ -73,7 +73,7 @@ module Projects
           project.ensure_repository
           project.repository.fetch_as_mirror(project.import_url, refmap: refmap)
         else
-          gitlab_shell.import_repository(project.repository_storage, project.disk_path, project.import_url)
+          gitlab_shell.import_project_repository(project)
         end
       rescue Gitlab::Shell::Error => e
         # Expire cache to prevent scenarios such as:

app/workers/repository_fork_worker.rb

@@ -15,19 +15,19 @@ class RepositoryForkWorker
       return target_project.import_state.mark_as_failed(_('Source project cannot be found.'))
     end
 
-    fork_repository(target_project, source_project.repository_storage, source_project.disk_path)
+    fork_repository(target_project, source_project)
   end
 
   private
 
-  def fork_repository(target_project, source_repository_storage_name, source_disk_path)
+  def fork_repository(target_project, source_project)
     return unless start_fork(target_project)
 
     Gitlab::Metrics.add_event(:fork_repository)
 
-    result = gitlab_shell.fork_repository(source_repository_storage_name, source_disk_path,
-                                          target_project.repository_storage, target_project.disk_path)
-    raise "Unable to fork project #{target_project.id} for repository #{source_disk_path} -> #{target_project.disk_path}" unless result
+    result = gitlab_shell.fork_repository(source_project, target_project)
+
+    raise "Unable to fork project #{target_project.id} for repository #{source_project.disk_path} -> #{target_project.disk_path}" unless result
 
     target_project.after_import
   end

db/migrate/20140502125220_migrate_repo_size.rb

@@ -11,7 +11,7 @@ class MigrateRepoSize < ActiveRecord::Migration[4.2]
       path = File.join(namespace_path, project['project_path'] + '.git')
 
       begin
-        repo = Gitlab::Git::Repository.new('default', path, '')
+        repo = Gitlab::Git::Repository.new('default', path, '', '')
         if repo.empty?
           print '-'
         else

ee/app/services/geo/base_sync_service.rb

@@ -79,7 +79,7 @@ module Geo
       log_info("Attempting to fetch repository via git")
 
       # `git fetch` needs an empty bare repository to fetch into
-      unless gitlab_shell.create_repository(project.repository_storage, disk_path_temp)
+      unless gitlab_shell.create_repository(project.repository_storage, disk_path_temp, project.full_path)
         raise Gitlab::Shell::Error, 'Can not create a temporary repository'
       end
 

ee/app/services/projects/update_repository_storage_service.rb

@@ -32,12 +32,14 @@ module Projects
       return false unless wait_for_pushes(wiki)
 
       repository = (wiki ? project.wiki.repository : project.repository).raw
+      full_path = wiki ? project.wiki.full_path : project.full_path
 
       # Initialize a git repository on the target path
-      gitlab_shell.create_repository(new_storage_key, repository.relative_path)
+      gitlab_shell.create_repository(new_storage_key, repository.relative_path, full_path)
       new_repository = Gitlab::Git::Repository.new(new_storage_key,
                                                    repository.relative_path,
-                                                   repository.gl_repository)
+                                                   repository.gl_repository,
+                                                   full_path)
 
       new_repository.fetch_repository_as_mirror(repository)
     end

ee/spec/services/projects/update_repository_storage_service_spec.rb

@@ -59,12 +59,12 @@ describe Projects::UpdateRepositoryStorageService do
 
         relative_path = project.repository.raw.relative_path
         allow(Gitlab::Git::Repository).to receive(:new)
-          .with('test_second_storage', relative_path, "project-#{project.id}")
+          .with('test_second_storage', relative_path, "project-#{project.id}", project.full_path)
           .and_return(repository_double)
 
         wiki_relative_path = project.wiki.repository.raw.relative_path
         allow(Gitlab::Git::Repository).to receive(:new)
-          .with('test_second_storage', wiki_relative_path, "wiki-#{project.id}")
+          .with('test_second_storage', wiki_relative_path, "wiki-#{project.id}", project.wiki.full_path)
           .and_return(wiki_repository_double)
       end
 

lib/backup/repository.rb

@@ -93,7 +93,7 @@ module Backup
             progress.puts "Error: #{e}".color(:red)
           end
         else
-          restore_repo_success = gitlab_shell.create_repository(project.repository_storage, project.disk_path)
+          restore_repo_success = gitlab_shell.create_project_repository(project)
         end
 
         if restore_repo_success

lib/gitlab/bitbucket_import/importer.rb

@@ -65,9 +65,9 @@ module Gitlab
       def import_wiki
         return if project.wiki.repository_exists?
 
-        disk_path = project.wiki.disk_path
-        import_url = project.import_url.sub(/\.git\z/, ".git/wiki")
-        gitlab_shell.import_repository(project.repository_storage, disk_path, import_url)
+        wiki = WikiFormatter.new(project)
+
+        gitlab_shell.import_wiki_repository(project, wiki)
       rescue StandardError => e
         errors << { type: :wiki, errors: e.message }
       end

lib/gitlab/bitbucket_import/wiki_formatter.rb

+# frozen_string_literal: true
+
+module Gitlab
+  module BitbucketImport
+    class WikiFormatter
+      attr_reader :project
+
+      def initialize(project)
+        @project = project
+      end
+
+      def disk_path
+        project.wiki.disk_path
+      end
+
+      def full_path
+        project.wiki.full_path
+      end
+
+      def import_url
+        project.import_url.sub(/\.git\z/, ".git/wiki")
+      end
+    end
+  end
+end

lib/gitlab/git/object_pool.rb

@@ -10,12 +10,13 @@ module Gitlab
       delegate :exists?, :size, to: :repository
       delegate :unlink_repository, :delete, to: :object_pool_service
 
-      attr_reader :storage, :relative_path, :source_repository
+      attr_reader :storage, :relative_path, :source_repository, :gl_project_path
 
-      def initialize(storage, relative_path, source_repository)
+      def initialize(storage, relative_path, source_repository, gl_project_path)
         @storage = storage
         @relative_path = relative_path
         @source_repository = source_repository
+        @gl_project_path = gl_project_path
       end
 
       def create
@@ -31,12 +32,12 @@ module Gitlab
       end
 
       def to_gitaly_repository
-        Gitlab::GitalyClient::Util.repository(storage, relative_path, GL_REPOSITORY)
+        Gitlab::GitalyClient::Util.repository(storage, relative_path, GL_REPOSITORY, gl_project_path)
       end
 
       # Allows for reusing other RPCs by 'tricking' Gitaly to think its a repository
       def repository
-        @repository ||= Gitlab::Git::Repository.new(storage, relative_path, GL_REPOSITORY)
+        @repository ||= Gitlab::Git::Repository.new(storage, relative_path, GL_REPOSITORY, gl_project_path)
       end
 
       private

lib/gitlab/git/repository.rb

@@ -67,7 +67,7 @@ module Gitlab
       # Relative path of repo
       attr_reader :relative_path
 
-      attr_reader :storage, :gl_repository, :relative_path
+      attr_reader :storage, :gl_repository, :relative_path, :gl_project_path
 
       # This remote name has to be stable for all types of repositories that
       # can join an object pool. If it's structure ever changes, a migration
@@ -78,10 +78,11 @@ module Gitlab
 
       # This initializer method is only used on the client side (gitlab-ce).
       # Gitaly-ruby uses a different initializer.
-      def initialize(storage, relative_path, gl_repository)
+      def initialize(storage, relative_path, gl_repository, gl_project_path)
         @storage = storage
         @relative_path = relative_path
         @gl_repository = gl_repository
+        @gl_project_path = gl_project_path
 
         @name = @relative_path.split("/").last
       end
@@ -872,7 +873,7 @@ module Gitlab
       end
 
       def gitaly_repository
-        Gitlab::GitalyClient::Util.repository(@storage, @relative_path, @gl_repository)
+        Gitlab::GitalyClient::Util.repository(@storage, @relative_path, @gl_repository, @gl_project_path)
       end
 
       def gitaly_ref_client

lib/gitlab/gitaly_client/util.rb

@@ -4,7 +4,7 @@ module Gitlab
   module GitalyClient
     module Util
       class << self
-        def repository(repository_storage, relative_path, gl_repository)
+        def repository(repository_storage, relative_path, gl_repository, gl_project_path)
           git_env = Gitlab::Git::HookEnv.all(gl_repository)
           git_object_directory = git_env['GIT_OBJECT_DIRECTORY_RELATIVE'].presence
           git_alternate_object_directories = Array.wrap(git_env['GIT_ALTERNATE_OBJECT_DIRECTORIES_RELATIVE'])
@@ -14,14 +14,16 @@ module Gitlab
             relative_path: relative_path,
             gl_repository: gl_repository.to_s,
             git_object_directory: git_object_directory.to_s,
-            git_alternate_object_directories: git_alternate_object_directories
+            git_alternate_object_directories: git_alternate_object_directories,
+            gl_project_path: gl_project_path
           )
         end
 
         def git_repository(gitaly_repository)
           Gitlab::Git::Repository.new(gitaly_repository.storage_name,
                                       gitaly_repository.relative_path,
-                                      gitaly_repository.gl_repository)
+                                      gitaly_repository.gl_repository,
+                                      gitaly_repository.gl_project_path)
         end
       end
     end

lib/gitlab/github_import/importer/repository_importer.rb

@@ -6,11 +6,12 @@ module Gitlab
       class RepositoryImporter
         include Gitlab::ShellAdapter
 
-        attr_reader :project, :client
+        attr_reader :project, :client, :wiki_formatter
 
         def initialize(project, client)
           @project = project
           @client = client
+          @wiki_formatter = ::Gitlab::LegacyGithubImport::WikiFormatter.new(project)
         end
 
         # Returns true if we should import the wiki for the project.
@@ -57,9 +58,7 @@ module Gitlab
         end
 
         def import_wiki_repository
-          wiki_path = "#{project.disk_path}.wiki"
-
-          gitlab_shell.import_repository(project.repository_storage, wiki_path, wiki_url)
+          gitlab_shell.import_wiki_repository(project, wiki_formatter)
 
           true
         rescue Gitlab::Shell::Error => e
@@ -72,7 +71,7 @@ module Gitlab
         end
 
         def wiki_url
-          project.import_url.sub(/\.git\z/, '.wiki.git')
+          wiki_formatter.import_url
         end
 
         def update_clone_time

lib/gitlab/legacy_github_import/importer.rb

@@ -267,7 +267,7 @@ module Gitlab
       def import_wiki
         unless project.wiki.repository_exists?
           wiki = WikiFormatter.new(project)
-          gitlab_shell.import_repository(project.repository_storage, wiki.disk_path, wiki.import_url)
+          gitlab_shell.import_wiki_repository(project, wiki)
         end
       rescue Gitlab::Shell::Error => e
         # GitHub error message when the wiki repo has not been created,

lib/gitlab/legacy_github_import/wiki_formatter.rb

@@ -13,6 +13,10 @@ module Gitlab
         project.wiki.disk_path
       end
 
+      def full_path
+        project.wiki.full_path
+      end
+
       def import_url
         project.import_url.sub(/\.git\z/, ".wiki.git")
       end

lib/gitlab/shell.rb

@@ -64,27 +64,48 @@ module Gitlab
       end
     end
 
+    # Convenience methods for initializing a new repository with a Project model.
+    def create_project_repository(project)
+      create_repository(project.repository_storage, project.disk_path, project.full_path)
+    end
+
+    def create_wiki_repository(project)
+      create_repository(project.repository_storage, project.wiki.disk_path, project.wiki.full_path)
+    end
+
     # Init new repository
     #
     # storage - the shard key
-    # name - project disk path
+    # disk_path - project disk path
+    # gl_project_path - project name
     #
     # Ex.
-    #   create_repository("default", "gitlab/gitlab-ci")
+    #   create_repository("default", "path/to/gitlab-ci", "gitlab/gitlab-ci")
     #
-    def create_repository(storage, name)
-      relative_path = name.dup
+    def create_repository(storage, disk_path, gl_project_path)
+      relative_path = disk_path.dup
       relative_path << '.git' unless relative_path.end_with?('.git')
 
-      repository = Gitlab::Git::Repository.new(storage, relative_path, '')
+      # During creation of a repository, gl_repository may not be known
+      # because that depends on a yet-to-be assigned project ID in the
+      # database (e.g. project-1234), so for now it is blank.
+      repository = Gitlab::Git::Repository.new(storage, relative_path, '', gl_project_path)
       wrapped_gitaly_errors { repository.gitaly_repository_client.create_repository }
 
       true
     rescue => err # Once the Rugged codes gets removes this can be improved
-      Rails.logger.error("Failed to add repository #{storage}/#{name}: #{err}")
+      Rails.logger.error("Failed to add repository #{storage}/#{disk_path}: #{err}")
       false
     end
 
+    def import_wiki_repository(project, wiki_formatter)
+      import_repository(project.repository_storage, wiki_formatter.disk_path, wiki_formatter.import_url, project.wiki.full_path)
+    end
+
+    def import_project_repository(project)
+      import_repository(project.repository_storage, project.disk_path, project.import_url, project.full_path)
+    end
+
     # Import repository
     #
     # storage - project's storage name
@@ -94,13 +115,13 @@ module Gitlab
     # Ex.
     #   import_repository("nfs-file06", "gitlab/gitlab-ci", "https://gitlab.com/gitlab-org/gitlab-test.git")
     #
-    def import_repository(storage, name, url)
+    def import_repository(storage, name, url, gl_project_path)
       if url.start_with?('.', '/')
         raise Error.new("don't use disk paths with import_repository: #{url.inspect}")
       end
 
       relative_path = "#{name}.git"
-      cmd = GitalyGitlabProjects.new(storage, relative_path)
+      cmd = GitalyGitlabProjects.new(storage, relative_path, gl_project_path)
 
       success = cmd.import_project(url, git_timeout)
       raise Error, cmd.output unless success
@@ -125,18 +146,13 @@ module Gitlab
     end
 
     # Fork repository to new path
-    # forked_from_storage - forked-from project's storage name
-    # forked_from_disk_path - project disk relative path
-    # forked_to_storage - forked-to project's storage name
-    # forked_to_disk_path - forked project disk relative path
-    #
-    # Ex.
-    #  fork_repository("nfs-file06", "gitlab/gitlab-ci", "nfs-file07", "new-namespace/gitlab-ci")
-    def fork_repository(forked_from_storage, forked_from_disk_path, forked_to_storage, forked_to_disk_path)
-      forked_from_relative_path = "#{forked_from_disk_path}.git"
-      fork_args = [forked_to_storage, "#{forked_to_disk_path}.git"]
+    # source_project - forked-from Project
+    # target_project - forked-to Project
+    def fork_repository(source_project, target_project)
+      forked_from_relative_path = "#{source_project.disk_path}.git"
+      fork_args = [target_project.repository_storage, "#{target_project.disk_path}.git", target_project.full_path]
 
-      GitalyGitlabProjects.new(forked_from_storage, forked_from_relative_path).fork_repository(*fork_args)
+      GitalyGitlabProjects.new(source_project.repository_storage, forked_from_relative_path, source_project.full_path).fork_repository(*fork_args)
     end
 
     # Removes a repository from file system, using rm_diretory which is an alias
@@ -397,16 +413,17 @@ module Gitlab
     end
 
     class GitalyGitlabProjects
-      attr_reader :shard_name, :repository_relative_path, :output
+      attr_reader :shard_name, :repository_relative_path, :output, :gl_project_path
 
-      def initialize(shard_name, repository_relative_path)
+      def initialize(shard_name, repository_relative_path, gl_project_path)
         @shard_name = shard_name
         @repository_relative_path = repository_relative_path
         @output = ''
+        @gl_project_path = gl_project_path
       end
 
       def import_project(source, _timeout)
-        raw_repository = Gitlab::Git::Repository.new(shard_name, repository_relative_path, nil)
+        raw_repository = Gitlab::Git::Repository.new(shard_name, repository_relative_path, nil, gl_project_path)
 
         Gitlab::GitalyClient::RepositoryService.new(raw_repository).import_repository(source)
         true
@@ -415,9 +432,9 @@ module Gitlab
         false
       end
 
-      def fork_repository(new_shard_name, new_repository_relative_path)
-        target_repository = Gitlab::Git::Repository.new(new_shard_name, new_repository_relative_path, nil)
-        raw_repository = Gitlab::Git::Repository.new(shard_name, repository_relative_path, nil)
+      def fork_repository(new_shard_name, new_repository_relative_path, new_project_name)
+        target_repository = Gitlab::Git::Repository.new(new_shard_name, new_repository_relative_path, nil, new_project_name)
+        raw_repository = Gitlab::Git::Repository.new(shard_name, repository_relative_path, nil, gl_project_path)
 
         Gitlab::GitalyClient::RepositoryService.new(target_repository).fork_repository(raw_repository)
       rescue GRPC::BadStatus => e

spec/lib/gitlab/bare_repository_import/repository_spec.rb

@@ -61,7 +61,7 @@ describe ::Gitlab::BareRepositoryImport::Repository do
     let(:wiki_path) { File.join(root_path, "#{hashed_path}.wiki.git") }
 
     before do
-      gitlab_shell.create_repository(repository_storage, hashed_path)
+      gitlab_shell.create_repository(repository_storage, hashed_path, 'group/project')
       Gitlab::GitalyClient::StorageSettings.allow_disk_access do
         repository = Rugged::Repository.new(repo_path)
         repository.config['gitlab.fullpath'] = 'to/repo'

spec/lib/gitlab/bitbucket_import/importer_spec.rb

@@ -218,7 +218,7 @@ describe Gitlab::BitbucketImport::Importer do
     describe 'wiki import' do
       it 'is skipped when the wiki exists' do
         expect(project.wiki).to receive(:repository_exists?) { true }
-        expect(importer.gitlab_shell).not_to receive(:import_repository)
+        expect(importer.gitlab_shell).not_to receive(:import_wiki_repository)
 
         importer.execute
 
@@ -227,11 +227,7 @@ describe Gitlab::BitbucketImport::Importer do
 
       it 'imports to the project disk_path' do
         expect(project.wiki).to receive(:repository_exists?) { false }
-        expect(importer.gitlab_shell).to receive(:import_repository).with(
-          project.repository_storage,
-          project.wiki.disk_path,
-          project.import_url + '/wiki'
-        )
+        expect(importer.gitlab_shell).to receive(:import_wiki_repository)
 
         importer.execute
 

spec/lib/gitlab/bitbucket_import/wiki_formatter_spec.rb

+require 'spec_helper'
+
+describe Gitlab::BitbucketImport::WikiFormatter do
+  let(:project) do
+    create(:project,
+           namespace: create(:namespace, path: 'gitlabhq'),
+           import_url: 'https://xxx@bitbucket.org/gitlabhq/sample.gitlabhq.git')
+  end
+
+  subject(:wiki) { described_class.new(project) }
+
+  describe '#disk_path' do
+    it 'appends .wiki to disk path' do
+      expect(wiki.disk_path).to eq project.wiki.disk_path
+    end
+  end
+
+  describe '#full_path' do
+    it 'appends .wiki to project path' do
+      expect(wiki.full_path).to eq project.wiki.full_path
+    end
+  end
+
+  describe '#import_url' do
+    it 'returns URL of the wiki repository' do
+      expect(wiki.import_url).to eq 'https://xxx@bitbucket.org/gitlabhq/sample.gitlabhq.git/wiki'
+    end
+  end
+end

spec/lib/gitlab/git/blame_spec.rb

@@ -2,7 +2,7 @@
 require "spec_helper"
 
 describe Gitlab::Git::Blame, :seed_helper do
-  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '') }
+  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '', 'group/project') }
   let(:blame) do
     Gitlab::Git::Blame.new(repository, SeedRepo::Commit::ID, "CONTRIBUTING.md")
   end

spec/lib/gitlab/git/blob_spec.rb

@@ -3,7 +3,7 @@
 require "spec_helper"
 
 describe Gitlab::Git::Blob, :seed_helper do
-  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '') }
+  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '', 'group/project') }
   let(:rugged) do
     Rugged::Repository.new(File.join(TestEnv.repos_path, TEST_REPO_PATH))
   end

spec/lib/gitlab/git/branch_spec.rb

 require "spec_helper"
 
 describe Gitlab::Git::Branch, :seed_helper do
-  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '') }
+  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '', 'group/project') }
   let(:rugged) do
     Rugged::Repository.new(File.join(TestEnv.repos_path, repository.relative_path))
   end
@@ -64,7 +64,7 @@ describe Gitlab::Git::Branch, :seed_helper do
 
   context 'with active, stale and future branches' do
     let(:repository) do
-      Gitlab::Git::Repository.new('default', TEST_MUTABLE_REPO_PATH, '')
+      Gitlab::Git::Repository.new('default', TEST_MUTABLE_REPO_PATH, '', 'group/project')
     end
 
     let(:user) { create(:user) }

spec/lib/gitlab/git/commit_spec.rb

@@ -3,7 +3,7 @@ require "spec_helper"
 describe Gitlab::Git::Commit, :seed_helper do
   include GitHelpers
 
-  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '') }
+  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '', 'group/project') }
   let(:rugged_repo) do
     Rugged::Repository.new(File.join(TestEnv.repos_path, TEST_REPO_PATH))
   end
@@ -146,7 +146,7 @@ describe Gitlab::Git::Commit, :seed_helper do
       end
 
       context 'with broken repo' do
-        let(:repository) { Gitlab::Git::Repository.new('default', TEST_BROKEN_REPO_PATH, '') }
+        let(:repository) { Gitlab::Git::Repository.new('default', TEST_BROKEN_REPO_PATH, '', 'group/project') }
 
         it 'returns nil' do
           expect(described_class.find(repository, SeedRepo::Commit::ID)).to be_nil

spec/lib/gitlab/git/compare_spec.rb

 require "spec_helper"
 
 describe Gitlab::Git::Compare, :seed_helper do
-  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '') }
+  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '', 'group/project') }
   let(:compare) { Gitlab::Git::Compare.new(repository, SeedRepo::BigCommit::ID, SeedRepo::Commit::ID, straight: false) }
   let(:compare_straight) { Gitlab::Git::Compare.new(repository, SeedRepo::BigCommit::ID, SeedRepo::Commit::ID, straight: true) }
 

spec/lib/gitlab/git/diff_spec.rb

 require "spec_helper"
 
 describe Gitlab::Git::Diff, :seed_helper do
-  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '') }
+  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '', 'group/project') }
   let(:gitaly_diff) do
     Gitlab::GitalyClient::Diff.new(
       from_path: '.gitmodules',

spec/lib/gitlab/git/remote_repository_spec.rb

 require 'spec_helper'
 
 describe Gitlab::Git::RemoteRepository, :seed_helper do
-  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '') }
+  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '', 'group/project') }
   subject { described_class.new(repository) }
 
   describe '#empty?' do
     using RSpec::Parameterized::TableSyntax
 
     where(:repository, :result) do
-      Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '')       | false
-      Gitlab::Git::Repository.new('default', 'does-not-exist.git', '') | true
+      Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '', 'group/project')       | false
+      Gitlab::Git::Repository.new('default', 'does-not-exist.git', '', 'group/project') | true
     end
 
     with_them do
@@ -44,11 +44,11 @@ describe Gitlab::Git::RemoteRepository, :seed_helper do
     using RSpec::Parameterized::TableSyntax
 
     where(:other_repository, :result) do
-      repository                                                                     | true
-      Gitlab::Git::Repository.new(repository.storage, repository.relative_path, '')  | true
-      Gitlab::Git::Repository.new('broken', TEST_REPO_PATH, '')                      | false
-      Gitlab::Git::Repository.new(repository.storage, 'wrong/relative-path.git', '') | false
-      Gitlab::Git::Repository.new('broken', 'wrong/relative-path.git', '')           | false
+      repository                                                                                      | true
+      Gitlab::Git::Repository.new(repository.storage, repository.relative_path, '', 'group/project')  | true
+      Gitlab::Git::Repository.new('broken', TEST_REPO_PATH, '', 'group/project')                      | false
+      Gitlab::Git::Repository.new(repository.storage, 'wrong/relative-path.git', '', 'group/project') | false
+      Gitlab::Git::Repository.new('broken', 'wrong/relative-path.git', '', 'group/project')           | false
     end
 
     with_them do

spec/lib/gitlab/git/repository_spec.rb

@@ -19,8 +19,8 @@ describe Gitlab::Git::Repository, :seed_helper do
     end
   end
 
-  let(:mutable_repository) { Gitlab::Git::Repository.new('default', TEST_MUTABLE_REPO_PATH, '') }
-  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '') }
+  let(:mutable_repository) { Gitlab::Git::Repository.new('default', TEST_MUTABLE_REPO_PATH, '', 'group/project') }
+  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '', 'group/project') }
   let(:repository_path) { File.join(TestEnv.repos_path, repository.relative_path) }
   let(:repository_rugged) { Rugged::Repository.new(repository_path) }
   let(:storage_path) { TestEnv.repos_path }
@@ -434,13 +434,13 @@ describe Gitlab::Git::Repository, :seed_helper do
 
   describe '#fetch_repository_as_mirror' do
     let(:new_repository) do
-      Gitlab::Git::Repository.new('default', 'my_project.git', '')
+      Gitlab::Git::Repository.new('default', 'my_project.git', '', 'group/project')
     end
 
     subject { new_repository.fetch_repository_as_mirror(repository) }
 
     before do
-      Gitlab::Shell.new.create_repository('default', 'my_project')
+      Gitlab::Shell.new.create_repository('default', 'my_project', 'group/project')
     end
 
     after do
@@ -1230,7 +1230,7 @@ describe Gitlab::Git::Repository, :seed_helper do
   end
 
   describe '#gitattribute' do
-    let(:repository) { Gitlab::Git::Repository.new('default', TEST_GITATTRIBUTES_REPO_PATH, '') }
+    let(:repository) { Gitlab::Git::Repository.new('default', TEST_GITATTRIBUTES_REPO_PATH, '', 'group/project') }
 
     after do
       ensure_seeds
@@ -1249,7 +1249,7 @@ describe Gitlab::Git::Repository, :seed_helper do
     end
 
     context 'without gitattributes file' do
-      let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '') }
+      let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '', 'group/project') }
 
       it 'returns nil' do
         expect(repository.gitattribute("README.md", 'gitlab-language')).to eq(nil)
@@ -1513,7 +1513,7 @@ describe Gitlab::Git::Repository, :seed_helper do
 
     context 'repository does not exist' do
       it 'raises NoRepository and does not call Gitaly WriteConfig' do
-        repository = Gitlab::Git::Repository.new('default', 'does/not/exist.git', '')
+        repository = Gitlab::Git::Repository.new('default', 'does/not/exist.git', '', 'group/project')
 
         expect(repository.gitaly_repository_client).not_to receive(:write_config)
 
@@ -1803,7 +1803,7 @@ describe Gitlab::Git::Repository, :seed_helper do
              out:   '/dev/null',
              err:   '/dev/null')
 
-      empty_repo = described_class.new('default', 'empty-repo.git', '')
+      empty_repo = described_class.new('default', 'empty-repo.git', '', 'group/empty-repo')
 
       expect(empty_repo.checksum).to eq '0000000000000000000000000000000000000000'
     end
@@ -1818,13 +1818,13 @@ describe Gitlab::Git::Repository, :seed_helper do
 
       File.truncate(File.join(storage_path, 'non-valid.git/HEAD'), 0)
 
-      non_valid = described_class.new('default', 'non-valid.git', '')
+      non_valid = described_class.new('default', 'non-valid.git', '', 'a/non-valid')
 
       expect { non_valid.checksum }.to raise_error(Gitlab::Git::Repository::InvalidRepository)
     end
 
     it 'raises Gitlab::Git::Repository::NoRepository error when there is no repo' do
-      broken_repo = described_class.new('default', 'a/path.git', '')
+      broken_repo = described_class.new('default', 'a/path.git', '', 'a/path')
 
       expect { broken_repo.checksum }.to raise_error(Gitlab::Git::Repository::NoRepository)
     end

spec/lib/gitlab/git/tag_spec.rb

 require "spec_helper"
 
 describe Gitlab::Git::Tag, :seed_helper do
-  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '') }
+  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '', 'group/project') }
 
   describe '#tags' do
     describe 'first tag' do

spec/lib/gitlab/git/tree_spec.rb

 require "spec_helper"
 
 describe Gitlab::Git::Tree, :seed_helper do
-  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '') }
+  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '', 'group/project') }
 
   context :repo do
     let(:tree) { Gitlab::Git::Tree.where(repository, SeedRepo::Commit::ID) }

spec/lib/gitlab/gitaly_client/remote_service_spec.rb

@@ -33,7 +33,7 @@ describe Gitlab::GitalyClient::RemoteService do
   end
 
   describe '#fetch_internal_remote' do
-    let(:remote_repository) { Gitlab::Git::Repository.new('default', TEST_MUTABLE_REPO_PATH, '') }
+    let(:remote_repository) { Gitlab::Git::Repository.new('default', TEST_MUTABLE_REPO_PATH, '', 'group/project') }
 
     it 'sends an fetch_internal_remote message and returns the result value' do
       expect_any_instance_of(Gitaly::RemoteService::Stub)

spec/lib/gitlab/gitaly_client/util_spec.rb

@@ -7,6 +7,7 @@ describe Gitlab::GitalyClient::Util do
     let(:gl_repository) { 'project-1' }
     let(:git_object_directory) { '.git/objects' }
     let(:git_alternate_object_directory) { ['/dir/one', '/dir/two'] }
+    let(:gl_project_path) { 'namespace/myproject' }
     let(:git_env) do
       {
         'GIT_OBJECT_DIRECTORY_RELATIVE' => git_object_directory,
@@ -15,7 +16,7 @@ describe Gitlab::GitalyClient::Util do
     end
 
     subject do
-      described_class.repository(repository_storage, relative_path, gl_repository)
+      described_class.repository(repository_storage, relative_path, gl_repository, gl_project_path)
     end
 
     it 'creates a Gitaly::Repository with the given data' do
@@ -27,6 +28,7 @@ describe Gitlab::GitalyClient::Util do
       expect(subject.gl_repository).to eq(gl_repository)
       expect(subject.git_object_directory).to eq(git_object_directory)
       expect(subject.git_alternate_object_directories).to eq(git_alternate_object_directory)
+      expect(subject.gl_project_path).to eq(gl_project_path)
     end
   end
 end

spec/lib/gitlab/github_import/importer/repository_importer_spec.rb

@@ -5,6 +5,14 @@ describe Gitlab::GithubImport::Importer::RepositoryImporter do
   let(:import_state) { double(:import_state) }
   let(:client) { double(:client) }
 
+  let(:wiki) do
+    double(
+      :wiki,
+      disk_path: 'foo.wiki',
+      full_path: 'group/foo.wiki'
+    )
+  end
+
   let(:project) do
     double(
       :project,
@@ -15,7 +23,9 @@ describe Gitlab::GithubImport::Importer::RepositoryImporter do
       repository: repository,
       create_wiki: true,
       import_state: import_state,
-      lfs_enabled?: true
+      full_path: 'group/foo',
+      lfs_enabled?: true,
+      wiki: wiki
     )
   end
 
@@ -195,7 +205,7 @@ describe Gitlab::GithubImport::Importer::RepositoryImporter do
     it 'imports the wiki repository' do
       expect(importer.gitlab_shell)
         .to receive(:import_repository)
-        .with('foo', 'foo.wiki', 'foo.wiki.git')
+        .with('foo', 'foo.wiki', 'foo.wiki.git', 'group/foo.wiki')
 
       expect(importer.import_wiki_repository).to eq(true)
     end

spec/lib/gitlab/legacy_github_import/wiki_formatter_spec.rb

@@ -10,11 +10,17 @@ describe Gitlab::LegacyGithubImport::WikiFormatter do
   subject(:wiki) { described_class.new(project) }
 
   describe '#disk_path' do
-    it 'appends .wiki to project path' do
+    it 'appends .wiki to disk path' do
       expect(wiki.disk_path).to eq project.wiki.disk_path
     end
   end
 
+  describe '#full_path' do
+    it 'appends .wiki to project path' do
+      expect(wiki.full_path).to eq project.wiki.full_path
+    end
+  end
+
   describe '#import_url' do
     it 'returns URL of the wiki repository' do
       expect(wiki.import_url).to eq 'https://xxx@github.com/gitlabhq/sample.gitlabhq.wiki.git'

spec/lib/gitlab/shell_spec.rb

@@ -412,7 +412,7 @@ describe Gitlab::Shell do
       end
 
       it 'creates a repository' do
-        expect(gitlab_shell.create_repository(repository_storage, repo_name)).to be_truthy
+        expect(gitlab_shell.create_repository(repository_storage, repo_name, repo_name)).to be_truthy
 
         expect(File.stat(created_path).mode & 0o777).to eq(0o770)
 
@@ -427,7 +427,7 @@ describe Gitlab::Shell do
         # should cause #create_repository to fail.
         FileUtils.touch(created_path)
 
-        expect(gitlab_shell.create_repository(repository_storage, repo_name)).to be_falsy
+        expect(gitlab_shell.create_repository(repository_storage, repo_name, repo_name)).to be_falsy
       end
     end
 
@@ -474,13 +474,10 @@ describe Gitlab::Shell do
     end
 
     describe '#fork_repository' do
+      let(:target_project) { create(:project) }
+
       subject do
-        gitlab_shell.fork_repository(
-          project.repository_storage,
-          project.disk_path,
-          'nfs-file05',
-          'fork/path'
-        )
+        gitlab_shell.fork_repository(project, target_project)
       end
 
       it 'returns true when the command succeeds' do
@@ -505,7 +502,7 @@ describe Gitlab::Shell do
         it 'returns true when the command succeeds' do
           expect_any_instance_of(Gitlab::GitalyClient::RepositoryService).to receive(:import_repository).with(import_url)
 
-          result = gitlab_shell.import_repository(project.repository_storage, project.disk_path, import_url)
+          result = gitlab_shell.import_repository(project.repository_storage, project.disk_path, import_url, project.full_path)
 
           expect(result).to be_truthy
         end
@@ -516,7 +513,7 @@ describe Gitlab::Shell do
           expect_any_instance_of(Gitlab::Shell::GitalyGitlabProjects).to receive(:output) { 'error'}
 
           expect do
-            gitlab_shell.import_repository(project.repository_storage, project.disk_path, import_url)
+            gitlab_shell.import_repository(project.repository_storage, project.disk_path, import_url, project.full_path)
           end.to raise_error(Gitlab::Shell::Error, "error")
         end
       end

spec/models/project_spec.rb

@@ -1893,7 +1893,7 @@ describe Project do
     context 'using a regular repository' do
       it 'creates the repository' do
         expect(shell).to receive(:create_repository)
-          .with(project.repository_storage, project.disk_path)
+          .with(project.repository_storage, project.disk_path, project.full_path)
           .and_return(true)
 
         expect(project.repository).to receive(:after_create)
@@ -1903,7 +1903,7 @@ describe Project do
 
       it 'adds an error if the repository could not be created' do
         expect(shell).to receive(:create_repository)
-          .with(project.repository_storage, project.disk_path)
+          .with(project.repository_storage, project.disk_path, project.full_path)
           .and_return(false)
 
         expect(project.repository).not_to receive(:after_create)
@@ -1936,7 +1936,7 @@ describe Project do
         .and_return(false)
 
       allow(shell).to receive(:create_repository)
-        .with(project.repository_storage, project.disk_path)
+        .with(project.repository_storage, project.disk_path, project.full_path)
         .and_return(true)
 
       expect(project).to receive(:create_repository).with(force: true)
@@ -1960,7 +1960,7 @@ describe Project do
         .and_return(false)
 
       expect(shell).to receive(:create_repository)
-        .with(project.repository_storage, project.disk_path)
+        .with(project.repository_storage, project.disk_path, project.full_path)
         .and_return(true)
 
       project.ensure_repository

spec/models/project_wiki_spec.rb

@@ -7,7 +7,7 @@ describe ProjectWiki do
   let(:repository) { project.repository }
   let(:gitlab_shell) { Gitlab::Shell.new }
   let(:project_wiki) { described_class.new(project, user) }
-  let(:raw_repository) { Gitlab::Git::Repository.new(project.repository_storage, subject.disk_path + '.git', 'foo') }
+  let(:raw_repository) { Gitlab::Git::Repository.new(project.repository_storage, subject.disk_path + '.git', 'foo', 'group/project.wiki') }
   let(:commit) { project_wiki.repository.head_commit }
 
   subject { project_wiki }
@@ -83,7 +83,7 @@ describe ProjectWiki do
       # Create a fresh project which will not have a wiki
       project_wiki = described_class.new(create(:project), user)
       gitlab_shell = double(:gitlab_shell)
-      allow(gitlab_shell).to receive(:create_repository)
+      allow(gitlab_shell).to receive(:create_wiki_repository)
       allow(project_wiki).to receive(:gitlab_shell).and_return(gitlab_shell)
 
       expect { project_wiki.send(:wiki) }.to raise_exception(ProjectWiki::CouldNotCreateWikiError)

spec/models/repository_spec.rb

@@ -2291,6 +2291,7 @@ describe Repository do
       expect(subject).to be_a(Gitlab::Git::Repository)
       expect(subject.relative_path).to eq(project.disk_path + '.git')
       expect(subject.gl_repository).to eq("project-#{project.id}")
+      expect(subject.gl_project_path).to eq(project.full_path)
     end
 
     context 'with a wiki repository' do
@@ -2300,6 +2301,7 @@ describe Repository do
         expect(subject).to be_a(Gitlab::Git::Repository)
         expect(subject.relative_path).to eq(project.disk_path + '.wiki.git')
         expect(subject.gl_repository).to eq("wiki-#{project.id}")
+        expect(subject.gl_project_path).to eq(project.full_path)
       end
     end
   end

spec/presenters/blob_presenter_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 describe BlobPresenter, :seed_helper do
-  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '') }
+  let(:repository) { Gitlab::Git::Repository.new('default', TEST_REPO_PATH, '', 'group/project') }
 
   let(:git_blob) do
     Gitlab::Git::Blob.find(

spec/services/projects/create_service_spec.rb

@@ -116,7 +116,7 @@ describe Projects::CreateService, '#execute' do
 
     def wiki_repo(project)
       relative_path = ProjectWiki.new(project).disk_path + '.git'
-      Gitlab::Git::Repository.new(project.repository_storage, relative_path, 'foobar')
+      Gitlab::Git::Repository.new(project.repository_storage, relative_path, 'foobar', project.full_path)
     end
   end
 
@@ -198,7 +198,7 @@ describe Projects::CreateService, '#execute' do
 
       context 'with legacy storage' do
         before do
-          gitlab_shell.create_repository(repository_storage, "#{user.namespace.full_path}/existing")
+          gitlab_shell.create_repository(repository_storage, "#{user.namespace.full_path}/existing", 'group/project')
         end
 
         after do
@@ -234,7 +234,7 @@ describe Projects::CreateService, '#execute' do
         end
 
         before do
-          gitlab_shell.create_repository(repository_storage, hashed_path)
+          gitlab_shell.create_repository(repository_storage, hashed_path, 'group/project')
         end
 
         after do

spec/services/projects/fork_service_spec.rb

@@ -119,7 +119,7 @@ describe Projects::ForkService do
         let(:repository_storage_path) { Gitlab.config.repositories.storages[repository_storage].legacy_disk_path }
 
         before do
-          gitlab_shell.create_repository(repository_storage, "#{@to_user.namespace.full_path}/#{@from_project.path}")
+          gitlab_shell.create_repository(repository_storage, "#{@to_user.namespace.full_path}/#{@from_project.path}", "#{@to_user.namespace.full_path}/#{@from_project.path}")
         end
 
         after do

spec/services/projects/transfer_service_spec.rb

@@ -201,7 +201,7 @@ describe Projects::TransferService do
     before do
       group.add_owner(user)
 
-      unless gitlab_shell.create_repository(repository_storage, "#{group.full_path}/#{project.path}")
+      unless gitlab_shell.create_repository(repository_storage, "#{group.full_path}/#{project.path}", project.full_path)
         raise 'failed to add repository'
       end
 

spec/services/projects/update_service_spec.rb

@@ -233,7 +233,7 @@ describe Projects::UpdateService, '#execute' do
         let(:project) { create(:project, :legacy_storage, :repository, creator: user, namespace: user.namespace) }
 
         before do
-          gitlab_shell.create_repository(repository_storage, "#{user.namespace.full_path}/existing")
+          gitlab_shell.create_repository(repository_storage, "#{user.namespace.full_path}/existing", user.namespace.full_path)
         end
 
         after do

spec/workers/repository_fork_worker_spec.rb

@@ -24,12 +24,7 @@ describe RepositoryForkWorker do
       end
 
       def expect_fork_repository
-        expect(shell).to receive(:fork_repository).with(
-          'default',
-          project.disk_path,
-          forked_project.repository_storage,
-          forked_project.disk_path
-        )
+        expect(shell).to receive(:fork_repository).with(project, forked_project)
       end
 
       describe 'when a worker was reset without cleanup' do