GitLab Shell doesn't require a path, now a shard name

Picked from CE, from: https://gitlab.com/gitlab-org/gitlab-ce/merge_requests/18364

But includes the EE changes too. Among the required changes are dropping
of repository_storage_path from Geo tables.

Geo stored `repository_storage_path` in four models, which initially was
modeled after the interface of Gitlab::Shell rather than storing only
the needed data. Given this inferred data had no place nor need to be
stored I opted for deleting it.

app/helpers/projects_helper.rb

@@ -451,7 +451,8 @@ module ProjectsHelper
     exports_path = File.join(Settings.shared['path'], 'tmp/project_exports')
     filtered_message = message.strip.gsub(exports_path, "[REPO EXPORT PATH]")
 
-    filtered_message.gsub(project.repository_storage_path.chomp('/'), "[REPOS PATH]")
+    disk_path = Gitlab.config.repositories.storages[project.repository_storage].legacy_disk_path
+    filtered_message.gsub(disk_path.chomp('/'), "[REPOS PATH]")
   end
 
   def project_child_container_class(view_path)

app/models/concerns/storage/legacy_namespace.rb

@@ -45,25 +45,25 @@ module Storage
 
     # Hooks
 
-    # Save the storage paths before the projects are destroyed to use them on after destroy
+    # Save the storages before the projects are destroyed to use them on after destroy
     def prepare_for_destroy
-      old_repository_storage_paths
+      old_repository_storages
     end
 
     private
 
     def move_repositories
-      # Move the namespace directory in all storage paths used by member projects
-      repository_storage_paths.each do |repository_storage_path|
+      # Move the namespace directory in all storages used by member projects
+      repository_storages.each do |repository_storage|
         # Ensure old directory exists before moving it
-        gitlab_shell.add_namespace(repository_storage_path, full_path_was)
+        gitlab_shell.add_namespace(repository_storage, full_path_was)
 
         # Ensure new directory exists before moving it (if there's a parent)
-        gitlab_shell.add_namespace(repository_storage_path, parent.full_path) if parent
+        gitlab_shell.add_namespace(repository_storage, parent.full_path) if parent
 
-        unless gitlab_shell.mv_namespace(repository_storage_path, full_path_was, full_path)
+        unless gitlab_shell.mv_namespace(repository_storage, full_path_was, full_path)
 
-          Rails.logger.error "Exception moving path #{repository_storage_path} from #{full_path_was} to #{full_path}"
+          Rails.logger.error "Exception moving path #{repository_storage} from #{full_path_was} to #{full_path}"
 
           # if we cannot move namespace directory we should rollback
           # db changes in order to prevent out of sync between db and fs
@@ -72,33 +72,33 @@ module Storage
       end
     end
 
-    def old_repository_storage_paths
-      @old_repository_storage_paths ||= repository_storage_paths
+    def old_repository_storages
+      @old_repository_storage_paths ||= repository_storages
     end
 
-    def repository_storage_paths
+    def repository_storages
       # We need to get the storage paths for all the projects, even the ones that are
       # pending delete. Unscoping also get rids of the default order, which causes
       # problems with SELECT DISTINCT.
       Project.unscoped do
-        all_projects.select('distinct(repository_storage)').to_a.map(&:repository_storage_path)
+        all_projects.select('distinct(repository_storage)').to_a.map(&:repository_storage)
       end
     end
 
     def rm_dir
       # Remove the namespace directory in all storages paths used by member projects
-      old_repository_storage_paths.each do |repository_storage_path|
+      old_repository_storages.each do |repository_storage|
         # Move namespace directory into trash.
         # We will remove it later async
         new_path = "#{full_path}+#{id}+deleted"
 
-        if gitlab_shell.mv_namespace(repository_storage_path, full_path, new_path)
+        if gitlab_shell.mv_namespace(repository_storage, full_path, new_path)
           Gitlab::AppLogger.info %Q(Namespace directory "#{full_path}" moved to "#{new_path}")
 
           # Remove namespace directroy async with delay so
           # GitLab has time to remove all projects first
           run_after_commit do
-            GitlabShellWorker.perform_in(5.minutes, :rm_namespace, repository_storage_path, new_path)
+            GitlabShellWorker.perform_in(5.minutes, :rm_namespace, repository_storage, new_path)
           end
         end
       end

app/models/project.rb

@@ -523,10 +523,6 @@ class Project < ActiveRecord::Base
     repository.empty?
   end
 
-  def repository_storage_path
-    Gitlab.config.repositories.storages[repository_storage]&.legacy_disk_path
-  end
-
   def team
     @team ||= ProjectTeam.new(self)
   end
@@ -1120,7 +1116,7 @@ class Project < ActiveRecord::Base
   # Check if repository already exists on disk
   def check_repository_path_availability
     return true if skip_disk_validation
-    return false unless repository_storage_path
+    return false unless repository_storage
 
     expires_full_path_cache # we need to clear cache to validate renames correctly
 
@@ -1921,14 +1917,14 @@ class Project < ActiveRecord::Base
   def check_repository_absence!
     return if skip_disk_validation
 
-    if repository_storage_path.blank? || repository_with_same_path_already_exists?
+    if repository_storage.blank? || repository_with_same_path_already_exists?
       errors.add(:base, 'There is already a repository with that name on disk')
       throw :abort
     end
   end
 
   def repository_with_same_path_already_exists?
-    gitlab_shell.exists?(repository_storage_path, "#{disk_path}.git")
+    gitlab_shell.exists?(repository_storage, "#{disk_path}.git")
   end
 
   # set last_activity_at to the same as created_at

app/models/project_wiki.rb

@@ -24,7 +24,7 @@ class ProjectWiki
   end
 
   delegate :empty?, to: :pages
-  delegate :repository_storage_path, :hashed_storage?, to: :project
+  delegate :repository_storage, :hashed_storage?, to: :project
 
   def path
     @project.path + '.wiki'
@@ -215,6 +215,8 @@ class ProjectWiki
   end
 
   def path_to_repo
-    @path_to_repo ||= File.join(project.repository_storage_path, "#{disk_path}.git")
+    @path_to_repo ||=
+      File.join(Gitlab.config.repositories.storages[project.repository_storage].legacy_disk_path,
+                "#{disk_path}.git")
   end
 end

app/models/repository.rb

@@ -91,9 +91,14 @@ class Repository
 
   # Return absolute path to repository
   def path_to_repo
-    @path_to_repo ||= File.expand_path(
-      File.join(repository_storage_path, disk_path + '.git')
-    )
+    @path_to_repo ||=
+      begin
+        storage = Gitlab.config.repositories.storages[@project.repository_storage]
+
+        File.expand_path(
+          File.join(storage.legacy_disk_path, disk_path + '.git')
+        )
+      end
   end
 
   def inspect
@@ -978,10 +983,6 @@ class Repository
     raw_repository.fetch_ref(source_repository.raw_repository, source_ref: source_ref, target_ref: target_ref)
   end
 
-  def repository_storage_path
-    @project.repository_storage_path
-  end
-
   def rebase(user, merge_request)
     raw.rebase(user, merge_request.id, branch: merge_request.source_branch,
                                        branch_sha: merge_request.source_branch_sha,

app/models/storage/hashed_project.rb

 module Storage
   class HashedProject
     attr_accessor :project
-    delegate :gitlab_shell, :repository_storage_path, to: :project
+    delegate :gitlab_shell, :repository_storage, to: :project
 
     ROOT_PATH_PREFIX = '@hashed'.freeze
 
@@ -24,7 +24,7 @@ module Storage
     end
 
     def ensure_storage_path_exists
-      gitlab_shell.add_namespace(repository_storage_path, base_dir)
+      gitlab_shell.add_namespace(repository_storage, base_dir)
     end
 
     def rename_repo

app/models/storage/legacy_project.rb

 module Storage
   class LegacyProject
     attr_accessor :project
-    delegate :namespace, :gitlab_shell, :repository_storage_path, to: :project
+    delegate :namespace, :gitlab_shell, :repository_storage, to: :project
 
     def initialize(project)
       @project = project
@@ -24,18 +24,18 @@ module Storage
     def ensure_storage_path_exists
       return unless namespace
 
-      gitlab_shell.add_namespace(repository_storage_path, base_dir)
+      gitlab_shell.add_namespace(repository_storage, base_dir)
     end
 
     def rename_repo
       new_full_path = project.build_full_path
 
-      if gitlab_shell.mv_repository(repository_storage_path, project.full_path_was, new_full_path)
+      if gitlab_shell.mv_repository(repository_storage, project.full_path_was, new_full_path)
         # If repository moved successfully we need to send update instructions to users.
         # However we cannot allow rollback since we moved repository
         # So we basically we mute exceptions in next actions
         begin
-          gitlab_shell.mv_repository(repository_storage_path, "#{project.full_path_was}.wiki", "#{new_full_path}.wiki")
+          gitlab_shell.mv_repository(repository_storage, "#{project.full_path_was}.wiki", "#{new_full_path}.wiki")
           return true
         rescue => e
           Rails.logger.error "Exception renaming #{project.full_path_was} -> #{new_full_path}: #{e}"

app/services/projects/destroy_service.rb

@@ -95,7 +95,7 @@ module Projects
 
         project.run_after_commit do
           # self is now project
-          GitlabShellWorker.perform_in(5.minutes, :remove_repository, self.repository_storage_path, new_path)
+          GitlabShellWorker.perform_in(5.minutes, :remove_repository, self.repository_storage, new_path)
         end
       else
         false
@@ -110,11 +110,13 @@ module Projects
     end
 
     def repo_exists?(path)
-      gitlab_shell.exists?(project.repository_storage_path, path + '.git')
+      gitlab_shell.exists?(project.repository_storage, path + '.git')
     end
 
     def mv_repository(from_path, to_path)
-      gitlab_shell.mv_repository(project.repository_storage_path, from_path, to_path)
+      return true unless gitlab_shell.exists?(project.repository_storage, from_path + '.git')
+
+      gitlab_shell.mv_repository(project.repository_storage, from_path, to_path)
     end
 
     def attempt_rollback(project, message)

app/services/projects/hashed_storage/migrate_repository_service.rb

@@ -49,8 +49,8 @@ module Projects
       private
 
       def move_repository(from_name, to_name)
-        from_exists = gitlab_shell.exists?(project.repository_storage_path, "#{from_name}.git")
-        to_exists = gitlab_shell.exists?(project.repository_storage_path, "#{to_name}.git")
+        from_exists = gitlab_shell.exists?(project.repository_storage, "#{from_name}.git")
+        to_exists = gitlab_shell.exists?(project.repository_storage, "#{to_name}.git")
 
         # If we don't find the repository on either original or target we should log that as it could be an issue if the
         # project was not originally empty.
@@ -62,7 +62,7 @@ module Projects
           return true
         end
 
-        gitlab_shell.mv_repository(project.repository_storage_path, from_name, to_name)
+        gitlab_shell.mv_repository(project.repository_storage, from_name, to_name)
       end
 
       def rollback_folder_move

app/services/projects/transfer_service.rb

@@ -129,7 +129,7 @@ module Projects
     end
 
     def move_repo_folder(from_name, to_name)
-      gitlab_shell.mv_repository(project.repository_storage_path, from_name, to_name)
+      gitlab_shell.mv_repository(project.repository_storage, from_name, to_name)
     end
 
     def execute_system_hooks

app/workers/repository_fork_worker.rb

@@ -13,7 +13,9 @@ class RepositoryForkWorker
     # See https://gitlab.com/gitlab-org/gitaly/issues/1110
     if args.empty?
       source_project = target_project.forked_from_project
-      return target_project.mark_import_as_failed('Source project cannot be found.') unless source_project
+      unless source_project
+        return target_project.mark_import_as_failed('Source project cannot be found.')
+      end
 
       fork_repository(target_project, source_project.repository_storage, source_project.disk_path)
     else

db/migrate/20161220141214_remove_dot_git_from_group_names.rb

@@ -59,17 +59,17 @@ class RemoveDotGitFromGroupNames < ActiveRecord::Migration
   end
 
   def move_namespace(group_id, path_was, path)
-    repository_storage_paths = select_all("SELECT distinct(repository_storage) FROM projects WHERE namespace_id = #{group_id}").map do |row|
+    repository_storages = select_all("SELECT distinct(repository_storage) FROM projects WHERE namespace_id = #{group_id}").map do |row|
       Gitlab.config.repositories.storages[row['repository_storage']].legacy_disk_path
     end.compact
 
     # Move the namespace directory in all storages paths used by member projects
-    repository_storage_paths.each do |repository_storage_path|
+    repository_storages.each do |repository_storage|
       # Ensure old directory exists before moving it
-      gitlab_shell.add_namespace(repository_storage_path, path_was)
+      gitlab_shell.add_namespace(repository_storage, path_was)
 
-      unless gitlab_shell.mv_namespace(repository_storage_path, path_was, path)
-        Rails.logger.error "Exception moving path #{repository_storage_path} from #{path_was} to #{path}"
+      unless gitlab_shell.mv_namespace(repository_storage, path_was, path)
+        Rails.logger.error "Exception moving on shard #{repository_storage} from #{path_was} to #{path}"
 
         # if we cannot move namespace directory we should rollback
         # db changes in order to prevent out of sync between db and fs

db/migrate/20161226122833_remove_dot_git_from_usernames.rb

@@ -53,8 +53,8 @@ class RemoveDotGitFromUsernames < ActiveRecord::Migration
     select_all("SELECT id, path FROM routes WHERE path = '#{quote_string(path)}'").present?
   end
 
-  def path_exists?(path, repository_storage_path)
-    repository_storage_path && gitlab_shell.exists?(repository_storage_path, path)
+  def path_exists?(shard, repository_storage_path)
+    repository_storage_path && gitlab_shell.exists?(shard, repository_storage_path)
   end
 
   # Accepts invalid path like test.git and returns test_git or
@@ -70,8 +70,8 @@ class RemoveDotGitFromUsernames < ActiveRecord::Migration
   def check_routes(base, counter, path)
     route_exists = route_exists?(path)
 
-    Gitlab.config.repositories.storages.each_value do |storage|
-      if route_exists || path_exists?(path, storage.legacy_disk_path)
+    Gitlab.config.repositories.storages.each do |shard, storage|
+      if route_exists || path_exists?(shard, storage.legacy_disk_path)
         counter += 1
         path = "#{base}#{counter}"
 

db/schema.rb

@@ -1020,7 +1020,6 @@ ActiveRecord::Schema.define(version: 20180419031622) do
   create_table "geo_hashed_storage_migrated_events", id: :bigserial, force: :cascade do |t|
     t.integer "project_id", null: false
     t.text "repository_storage_name", null: false
-    t.text "repository_storage_path", null: false
     t.text "old_disk_path", null: false
     t.text "new_disk_path", null: false
     t.text "old_wiki_disk_path", null: false
@@ -1126,7 +1125,6 @@ ActiveRecord::Schema.define(version: 20180419031622) do
   create_table "geo_repository_created_events", id: :bigserial, force: :cascade do |t|
     t.integer "project_id", null: false
     t.text "repository_storage_name", null: false
-    t.text "repository_storage_path", null: false
     t.text "repo_path", null: false
     t.text "wiki_path"
     t.text "project_name", null: false
@@ -1137,7 +1135,6 @@ ActiveRecord::Schema.define(version: 20180419031622) do
   create_table "geo_repository_deleted_events", id: :bigserial, force: :cascade do |t|
     t.integer "project_id", null: false
     t.text "repository_storage_name", null: false
-    t.text "repository_storage_path", null: false
     t.text "deleted_path", null: false
     t.text "deleted_wiki_path"
     t.text "deleted_project_name", null: false
@@ -1148,7 +1145,6 @@ ActiveRecord::Schema.define(version: 20180419031622) do
   create_table "geo_repository_renamed_events", id: :bigserial, force: :cascade do |t|
     t.integer "project_id", null: false
     t.text "repository_storage_name", null: false
-    t.text "repository_storage_path", null: false
     t.text "old_path_with_namespace", null: false
     t.text "new_path_with_namespace", null: false
     t.text "old_wiki_path_with_namespace", null: false

ee/app/models/geo/deleted_project.rb

@@ -18,10 +18,6 @@ class Geo::DeletedProject
     @repository_storage ||= Gitlab::CurrentSettings.pick_repository_storage
   end
 
-  def repository_storage_path
-    Gitlab.config.repositories.storages[repository_storage]&.legacy_disk_path
-  end
-
   def wiki
     @wiki ||= ProjectWiki.new(self, nil)
   end

ee/app/models/geo/hashed_storage_migrated_event.rb

@@ -4,7 +4,7 @@ module Geo
 
     belongs_to :project
 
-    validates :project, :repository_storage_name, :repository_storage_path,
+    validates :project, :repository_storage_name,
               :old_disk_path, :new_disk_path, :old_wiki_disk_path,
               :new_wiki_disk_path, :new_storage_version, presence: true
   end

ee/app/models/geo/repository_created_event.rb

@@ -4,7 +4,6 @@ module Geo
 
     belongs_to :project
 
-    validates :project, :project_name, :repo_path, :repository_storage_name,
-              :repository_storage_path, presence: true
+    validates :project, :project_name, :repo_path, :repository_storage_name, presence: true
   end
 end

ee/app/models/geo/repository_renamed_event.rb

@@ -4,9 +4,9 @@ module Geo
 
     belongs_to :project
 
-    validates :project, :repository_storage_name, :repository_storage_path,
-              :old_path_with_namespace, :new_path_with_namespace,
-              :old_wiki_path_with_namespace, :new_wiki_path_with_namespace,
-              :old_path, :new_path, presence: true
+    validates :project, :repository_storage_name, :old_path_with_namespace,
+      :new_path_with_namespace, :old_wiki_path_with_namespace,
+      :new_wiki_path_with_namespace,
+      :old_path, :new_path, presence: true
   end
 end

ee/app/services/geo/base_sync_service.rb

@@ -219,9 +219,9 @@ module Geo
     end
 
     def clean_up_temporary_repository
-      exists = gitlab_shell.exists?(project.repository_storage_path, disk_path_temp)
+      exists = gitlab_shell.exists?(project.repository_storage, disk_path_temp)
 
-      if exists && !gitlab_shell.remove_repository(project.repository_storage_path, disk_path_temp)
+      if exists && !gitlab_shell.remove_repository(project.repository_storage, disk_path_temp)
         raise Gitlab::Shell::Error, "Temporary #{type} can not be removed"
       end
     end
@@ -229,14 +229,14 @@ module Geo
     def set_temp_repository_as_main
       log_info(
         "Setting newly downloaded repository as main",
-        storage_path: project.repository_storage_path,
+        storage_shard: project.repository_storage,
         temp_path: disk_path_temp,
         deleted_disk_path_temp: deleted_disk_path_temp,
         disk_path: repository.disk_path
       )
 
       # Remove the deleted path in case it exists, but it may not be there
-      gitlab_shell.remove_repository(project.repository_storage_path, deleted_disk_path_temp)
+      gitlab_shell.remove_repository(project.repository_storage, deleted_disk_path_temp)
 
       # Make sure we have the most current state of exists?
       repository.expire_exists_cache
@@ -245,7 +245,7 @@ module Geo
       if repository.exists?
         ensure_repository_namespace(deleted_disk_path_temp)
 
-        unless gitlab_shell.mv_repository(project.repository_storage_path, repository.disk_path, deleted_disk_path_temp)
+        unless gitlab_shell.mv_repository(project.repository_storage, repository.disk_path, deleted_disk_path_temp)
           raise Gitlab::Shell::Error, 'Can not move original repository out of the way'
         end
       end
@@ -254,19 +254,19 @@ module Geo
 
       ensure_repository_namespace(repository.disk_path)
 
-      unless gitlab_shell.mv_repository(project.repository_storage_path, disk_path_temp, repository.disk_path)
+      unless gitlab_shell.mv_repository(project.repository_storage, disk_path_temp, repository.disk_path)
         raise Gitlab::Shell::Error, 'Can not move temporary repository to canonical location'
       end
 
       # Purge the original repository
-      unless gitlab_shell.remove_repository(project.repository_storage_path, deleted_disk_path_temp)
+      unless gitlab_shell.remove_repository(project.repository_storage, deleted_disk_path_temp)
         raise Gitlab::Shell::Error, 'Can not remove outdated main repository'
       end
     end
 
     def ensure_repository_namespace(disk_path)
       gitlab_shell.add_namespace(
-        project.repository_storage_path,
+        project.repository_storage,
         File.dirname(disk_path)
       )
     end

ee/app/services/geo/hashed_storage_migrated_event_store.rb

@@ -10,7 +10,6 @@ module Geo
         old_storage_version: old_storage_version,
         new_storage_version: project.storage_version,
         repository_storage_name: project.repository.storage,
-        repository_storage_path: project.repository_storage_path,
         old_disk_path: old_disk_path,
         new_disk_path: project.disk_path,
         old_wiki_disk_path: old_wiki_disk_path,

ee/app/services/geo/move_repository_service.rb

@@ -52,11 +52,11 @@ module Geo
     end
 
     def move_project_repository
-      gitlab_shell.mv_repository(project.repository_storage_path, old_disk_path, new_disk_path)
+      gitlab_shell.mv_repository(project.repository_storage, old_disk_path, new_disk_path)
     end
 
     def move_wiki_repository
-      gitlab_shell.mv_repository(project.repository_storage_path, "#{old_disk_path}.wiki", "#{new_disk_path}.wiki")
+      gitlab_shell.mv_repository(project.repository_storage, "#{old_disk_path}.wiki", "#{new_disk_path}.wiki")
     end
   end
 end

ee/app/services/geo/repository_created_event_store.rb

@@ -8,7 +8,6 @@ module Geo
       Geo::RepositoryCreatedEvent.new(
         project: project,
         repository_storage_name: project.repository.storage,
-        repository_storage_path: project.repository_storage_path,
         repo_path: project.disk_path,
         wiki_path: (project.wiki.disk_path if project.wiki_enabled?),
         project_name: project.name

ee/app/services/geo/repository_deleted_event_store.rb

@@ -8,7 +8,6 @@ module Geo
       Geo::RepositoryDeletedEvent.new(
         project: project,
         repository_storage_name: project.repository.storage,
-        repository_storage_path: project.repository_storage_path,
         deleted_path: params.fetch(:repo_path),
         deleted_wiki_path: params.fetch(:wiki_path),
         deleted_project_name: project.name)

ee/app/services/geo/repository_renamed_event_store.rb

@@ -8,7 +8,6 @@ module Geo
       Geo::RepositoryRenamedEvent.new(
         project: project,
         repository_storage_name: project.repository.storage,
-        repository_storage_path: project.repository_storage_path,
         old_path_with_namespace: old_path_with_namespace,
         new_path_with_namespace: project.disk_path,
         old_wiki_path_with_namespace: old_wiki_path_with_namespace,

ee/app/services/projects/update_repository_storage_service.rb

@@ -39,20 +39,20 @@ module Projects
     end
 
     def mark_old_paths_for_archive
-      old_repository_storage_path = project.repository_storage_path
+      old_repository_storage = project.repository_storage
       new_project_path = moved_path(project.disk_path)
 
       # Notice that the block passed to `run_after_commit` will run with `project`
       # as its context
       project.run_after_commit do
         GitlabShellWorker.perform_async(:mv_repository,
-                                        old_repository_storage_path,
+                                        old_repository_storage,
                                         disk_path,
                                         new_project_path)
 
         if wiki.repository_exists?
           GitlabShellWorker.perform_async(:mv_repository,
-                                          old_repository_storage_path,
+                                          old_repository_storage,
                                           wiki.disk_path,
                                           "#{new_project_path}.wiki")
         end

ee/app/workers/geo/repositories_clean_up_worker.rb

@@ -28,7 +28,7 @@ module Geo
 
     def clean_up_repositories(project)
       # There is a possibility project does not have repository or wiki
-      return true unless gitlab_shell.exists?(project.repository_storage_path, "#{project.disk_path}.git")
+      return true unless gitlab_shell.exists?(project.repository_storage, "#{project.disk_path}.git")
 
       job_id = ::GeoRepositoryDestroyWorker.perform_async(project.id, project.name, project.disk_path, project.repository.storage)
 

ee/db/post_migrate/20180417102933_drop_repository_storage_events_for_geo_events.rb

+# See http://doc.gitlab.com/ce/development/migration_style_guide.html
+# for more information on how to write migrations for GitLab.
+
+class DropRepositoryStorageEventsForGeoEvents < ActiveRecord::Migration
+  include Gitlab::Database::MigrationHelpers
+
+  DOWNTIME = false
+  BATCH_SIZE = 5_000
+  TABLES = %i(geo_hashed_storage_migrated_events geo_repository_created_events
+              geo_repository_deleted_events geo_repository_renamed_events)
+
+  def up
+    TABLES.each { |t| remove_column(t, :repository_storage_path) }
+  end
+
+  def down
+    TABLES.each { |t| add_column(t, :repository_storage_path, :text) }
+
+    add_shard_path
+  end
+
+  private
+
+  def add_shard_path
+    TABLES.each do |t|
+      min_id = 0
+
+      loop do
+        newest = newest_entry(t)
+        break unless newest
+        break if newest['repository_storage_path'].present?
+
+        new_batch = batch(t, min_id)
+        update_batch(t, new_batch)
+
+        min_id = new_batch.last.to_i
+      end
+
+      change_column_null(t, :repository_storage_path, true)
+    end
+  end
+
+  def newest_entry(table)
+    execute(
+      <<~SQL
+      SELECT id, repository_storage_path
+      FROM #{table}
+      ORDER BY id DESC
+      LIMIT 1;
+      SQL
+    ).first
+  end
+
+  def batch(table, min_id)
+    execute(
+      <<~SQL
+        SELECT id
+        FROM #{table}
+        WHERE id > #{min_id}
+        ORDER BY id ASC
+        LIMIT #{BATCH_SIZE};
+      SQL
+    ).map { |row| row['id'] }
+  end
+
+  def update_batch(table, ids)
+    execute(
+      <<~SQL
+      UPDATE #{table}
+      SET repository_storage_path =
+        CASE repository_storage_name
+          #{case_statements}
+        END
+      WHERE id IN (#{ids.join(',')})
+      SQL
+    )
+  end
+
+  def case_statements
+    statement = ""
+    Gitlab.config.repositories.storages.each do |shard, data|
+      statement << "WHEN '#{shard}' THEN '#{data.legacy_disk_path}'\n"
+    end
+
+    statement
+  end
+end

ee/spec/factories/geo/event_log.rb

@@ -41,7 +41,6 @@ FactoryBot.define do
     project
 
     repository_storage_name { project.repository_storage }
-    repository_storage_path { project.repository_storage_path }
     add_attribute(:repo_path) { project.disk_path }
     project_name { project.name }
     wiki_path { project.wiki.disk_path }
@@ -59,7 +58,6 @@ FactoryBot.define do
     project
 
     repository_storage_name { project.repository_storage }
-    repository_storage_path { project.repository_storage_path }
     deleted_path { project.full_path }
     deleted_project_name { project.name }
   end
@@ -72,7 +70,6 @@ FactoryBot.define do
     project { create(:project, :repository) }
 
     repository_storage_name { project.repository_storage }
-    repository_storage_path { project.repository_storage_path }
     old_path_with_namespace { project.path_with_namespace }
     new_path_with_namespace { project.path_with_namespace + '_new' }
     old_wiki_path_with_namespace { project.wiki.path_with_namespace }
@@ -85,7 +82,6 @@ FactoryBot.define do
     project { create(:project, :repository) }
 
     repository_storage_name { project.repository_storage }
-    repository_storage_path { project.repository_storage_path }
     old_disk_path { project.path_with_namespace }
     new_disk_path { project.path_with_namespace + '_new' }
     old_wiki_disk_path { project.wiki.path_with_namespace }

ee/spec/migrations/drop_repository_storage_events_for_geo_events_spec.rb

+# encoding: utf-8
+
+require 'spec_helper'
+require Rails.root.join('ee', 'db', 'post_migrate', '20180417102933_drop_repository_storage_events_for_geo_events.rb')
+
+describe DropRepositoryStorageEventsForGeoEvents, :migration do
+  let(:migration) { described_class.new }
+
+  describe '#up' do
+    before do
+      migration.up
+    end
+
+    it 'dropped the repository_storage_path column' do
+      described_class::TABLES.each do |table_name|
+        columns = table(table_name).columns.map(&:name)
+
+        expect(columns).not_to include("repository_storage_path")
+      end
+    end
+  end
+
+  describe '#down' do
+    let(:event_name) { :geo_repository_created_event }
+
+    before do
+      described_class.const_set(:BATCH_SIZE, 1)
+
+      Gitlab.config.repositories.storages.each do |name, _|
+        described_class.execute(<<~SQL
+                                INSERT INTO #{event_name}s (project_id, project_name, repository_storage_name, repo_path)
+                                VALUES (1, 'mepmep', '#{name}', 'path/to/gitlab-org')
+                                SQL
+                               )
+      end
+
+      migration.down
+      reset_column_in_all_models
+    end
+
+    it 'created the repository_storage_path column' do
+      described_class::TABLES.each do |table_name|
+        columns = table(table_name).columns.map(&:name)
+
+        expect(columns).to include("repository_storage_path")
+      end
+
+      null_columns = described_class
+        .execute("SELECT COUNT(*) FROM #{event_name}s WHERE repository_storage_path IS NULL;")
+        .first['count']
+
+      expect(null_columns.to_i).to be(0)
+    end
+  end
+end

ee/spec/models/geo/deleted_project_spec.rb

@@ -45,12 +45,6 @@ RSpec.describe Geo::DeletedProject, type: :model do
     end
   end
 
-  describe '#repository_storage_path' do
-    it 'returns the repository storage path' do
-      expect(subject.repository_storage_path).to eq(File.absolute_path('tmp/tests/storage_foo'))
-    end
-  end
-
   describe '#wiki' do
     it 'returns a valid wiki repository' do
       expect(subject.wiki).to be_kind_of(ProjectWiki)
@@ -66,9 +60,9 @@ RSpec.describe Geo::DeletedProject, type: :model do
 
   describe '#run_after_commit' do
     it 'runs the given block changing self to the caller' do
-      expect(subject).to receive(:repository_storage_path).once
+      expect(subject).to receive(:repository_storage).once
 
-      subject.run_after_commit { self.repository_storage_path }
+      subject.run_after_commit { self.repository_storage }
     end
   end
 end

ee/spec/models/geo/hashed_storage_migrated_event_spec.rb

@@ -8,7 +8,6 @@ RSpec.describe Geo::HashedStorageMigratedEvent, type: :model do
   describe 'validations' do
     it { is_expected.to validate_presence_of(:project) }
     it { is_expected.to validate_presence_of(:repository_storage_name) }
-    it { is_expected.to validate_presence_of(:repository_storage_path) }
     it { is_expected.to validate_presence_of(:old_disk_path) }
     it { is_expected.to validate_presence_of(:new_disk_path) }
     it { is_expected.to validate_presence_of(:old_wiki_disk_path) }

ee/spec/models/geo/repository_created_event_spec.rb

@@ -10,6 +10,5 @@ describe Geo::RepositoryCreatedEvent, type: :model do
     it { is_expected.to validate_presence_of(:project_name) }
     it { is_expected.to validate_presence_of(:repo_path) }
     it { is_expected.to validate_presence_of(:repository_storage_name) }
-    it { is_expected.to validate_presence_of(:repository_storage_path) }
   end
 end

ee/spec/models/geo/repository_renamed_event_spec.rb

@@ -8,7 +8,6 @@ RSpec.describe Geo::RepositoryRenamedEvent, type: :model do
   describe 'validations' do
     it { is_expected.to validate_presence_of(:project) }
     it { is_expected.to validate_presence_of(:repository_storage_name) }
-    it { is_expected.to validate_presence_of(:repository_storage_path) }
     it { is_expected.to validate_presence_of(:old_path_with_namespace) }
     it { is_expected.to validate_presence_of(:new_path_with_namespace) }
     it { is_expected.to validate_presence_of(:old_wiki_path_with_namespace) }

ee/spec/models/namespace_spec.rb

@@ -114,7 +114,7 @@ describe Namespace do
         allow(parent).to receive(:full_path).and_return(new_path)
 
         allow(gitlab_shell).to receive(:mv_namespace)
-          .with(project_legacy_storage.repository_storage_path, full_path_was, new_path)
+          .with(project_legacy_storage.repository_storage, full_path_was, new_path)
           .and_return(true)
 
         expect { parent.move_dir }.to change(Geo::RepositoryRenamedEvent, :count).by(3)

ee/spec/services/geo/hashed_storage_migrated_event_store_spec.rb

@@ -41,7 +41,6 @@ describe Geo::HashedStorageMigratedEventStore do
 
         expect(event).to have_attributes(
           repository_storage_name: project.repository_storage,
-          repository_storage_path: project.repository_storage_path,
           old_storage_version: nil,
           new_storage_version: project.storage_version,
           old_disk_path: old_disk_path,

ee/spec/services/geo/hashed_storage_migration_service_spec.rb

@@ -22,7 +22,7 @@ describe Geo::HashedStorageMigrationService do
 
       it 'raises an error when project repository can not be moved' do
         allow_any_instance_of(Gitlab::Shell).to receive(:mv_repository)
-          .with(project.repository_storage_path, old_path, new_path)
+          .with(project.repository_storage, old_path, new_path)
           .and_return(false)
 
         expect { service.execute }.to raise_error(Geo::RepositoryCannotBeRenamed, "Repository #{old_path} could not be renamed to #{new_path}")
@@ -30,11 +30,11 @@ describe Geo::HashedStorageMigrationService do
 
       it 'raises an error when wiki repository can not be moved' do
         allow_any_instance_of(Gitlab::Shell).to receive(:mv_repository)
-          .with(project.repository_storage_path, old_path, new_path)
+          .with(project.repository_storage, old_path, new_path)
           .and_return(true)
 
         allow_any_instance_of(Gitlab::Shell).to receive(:mv_repository)
-          .with(project.repository_storage_path, "#{old_path}.wiki", "#{new_path}.wiki")
+          .with(project.repository_storage, "#{old_path}.wiki", "#{new_path}.wiki")
           .and_return(false)
 
         expect { service.execute }.to raise_error(Geo::RepositoryCannotBeRenamed, "Repository #{old_path} could not be renamed to #{new_path}")

ee/spec/services/geo/move_repository_service_spec.rb

@@ -5,13 +5,17 @@ describe Geo::MoveRepositoryService, :geo do
     let(:project) { create(:project, :repository, :wiki_repo, :legacy_storage) }
     let(:old_path) { project.full_path }
     let(:new_path) { "#{project.full_path}+renamed" }
+    let(:gitlab_shell) { Gitlab::Shell.new }
 
     subject(:service) { described_class.new(project, old_path, new_path) }
 
     it 'renames the project repositories' do
       old_disk_path = project.repository.path_to_repo
       old_wiki_disk_path = project.wiki.repository.path_to_repo
-      full_new_path = File.join(project.repository_storage_path, new_path)
+      full_new_path = File.join(
+        Gitlab.config.repositories.storages[project.repository_storage].legacy_disk_path,
+        new_path
+      )
 
       expect(File.directory?(old_disk_path)).to be_truthy
       expect(File.directory?(old_wiki_disk_path)).to be_truthy
@@ -24,7 +28,7 @@ describe Geo::MoveRepositoryService, :geo do
 
     it 'returns false when project repository can not be renamed' do
       allow_any_instance_of(Gitlab::Shell).to receive(:mv_repository)
-        .with(project.repository_storage_path, old_path, new_path)
+        .with(project.repository_storage, old_path, new_path)
         .and_return(false)
 
       expect(service).to receive(:log_error).with('Repository cannot be moved')
@@ -34,11 +38,11 @@ describe Geo::MoveRepositoryService, :geo do
 
     it 'returns false when wiki repository can not be renamed' do
       allow_any_instance_of(Gitlab::Shell).to receive(:mv_repository)
-        .with(project.repository_storage_path, old_path, new_path)
+        .with(project.repository_storage, old_path, new_path)
         .and_return(true)
 
       allow_any_instance_of(Gitlab::Shell).to receive(:mv_repository)
-        .with(project.repository_storage_path, "#{old_path}.wiki", "#{new_path}.wiki")
+        .with(project.repository_storage, "#{old_path}.wiki", "#{new_path}.wiki")
         .and_return(false)
 
       expect(service).to receive(:log_error).with('Wiki repository cannot be moved')
@@ -51,11 +55,11 @@ describe Geo::MoveRepositoryService, :geo do
 
       it 'tries to move wiki even if it is not enabled without reporting error' do
         allow_any_instance_of(Gitlab::Shell).to receive(:mv_repository)
-          .with(project.repository_storage_path, old_path, new_path)
+          .with(project.repository_storage, old_path, new_path)
           .and_return(true)
 
         allow_any_instance_of(Gitlab::Shell).to receive(:mv_repository)
-          .with(project.repository_storage_path, "#{old_path}.wiki", "#{new_path}.wiki")
+          .with(project.repository_storage, "#{old_path}.wiki", "#{new_path}.wiki")
           .and_return(false)
 
         expect(service).not_to receive(:log_error)

ee/spec/services/geo/rename_repository_service_spec.rb

@@ -22,7 +22,7 @@ describe Geo::RenameRepositoryService do
 
       it 'raises an error when project repository can not be moved' do
         allow_any_instance_of(Gitlab::Shell).to receive(:mv_repository)
-          .with(project.repository_storage_path, old_path, new_path)
+          .with(project.repository_storage, old_path, new_path)
           .and_return(false)
 
         expect { service.execute }.to raise_error(Geo::RepositoryCannotBeRenamed, "Repository #{old_path} could not be renamed to #{new_path}")
@@ -30,11 +30,11 @@ describe Geo::RenameRepositoryService do
 
       it 'raises an error when wiki repository can not be moved' do
         allow_any_instance_of(Gitlab::Shell).to receive(:mv_repository)
-          .with(project.repository_storage_path, old_path, new_path)
+          .with(project.repository_storage, old_path, new_path)
           .and_return(true)
 
         allow_any_instance_of(Gitlab::Shell).to receive(:mv_repository)
-          .with(project.repository_storage_path, "#{old_path}.wiki", "#{new_path}.wiki")
+          .with(project.repository_storage, "#{old_path}.wiki", "#{new_path}.wiki")
           .and_return(false)
 
         expect { service.execute }.to raise_error(Geo::RepositoryCannotBeRenamed, "Repository #{old_path} could not be renamed to #{new_path}")

ee/spec/services/geo/repository_created_event_store_spec.rb

@@ -38,8 +38,7 @@ describe Geo::RepositoryCreatedEventStore do
           repo_path: project.disk_path,
           wiki_path: project.wiki.disk_path,
           project_name: project.name,
-          repository_storage_name: project.repository_storage,
-          repository_storage_path: project.repository_storage_path
+          repository_storage_name: project.repository_storage
         )
       end
 

ee/spec/services/geo/repository_deleted_event_store_spec.rb

@@ -8,7 +8,6 @@ describe Geo::RepositoryDeletedEventStore do
   let(:repo_path) { project.full_path }
   let(:wiki_path) { "#{project.full_path}.wiki" }
   let(:storage_name) { project.repository_storage }
-  let(:storage_path) { project.repository_storage_path }
 
   subject { described_class.new(project, repo_path: repo_path, wiki_path: wiki_path) }
 
@@ -44,7 +43,6 @@ describe Geo::RepositoryDeletedEventStore do
         expect(event.deleted_wiki_path).to eq(wiki_path)
         expect(event.deleted_project_name).to eq(project_name)
         expect(event.repository_storage_name).to eq(storage_name)
-        expect(event.repository_storage_path).to eq(storage_path)
       end
     end
   end

ee/spec/services/geo/repository_destroy_service_spec.rb

@@ -33,18 +33,18 @@ describe Geo::RepositoryDestroyService do
       it 'removes the repository from disk' do
         project.delete
 
-        expect(project.gitlab_shell.exists?(project.repository_storage_path, "#{project.disk_path}.git")).to be_truthy
+        expect(project.gitlab_shell.exists?(project.repository_storage, "#{project.disk_path}.git")).to be_truthy
 
         service.execute
 
-        expect(project.gitlab_shell.exists?(project.repository_storage_path, "#{project.disk_path}.git")).to be_falsey
+        expect(project.gitlab_shell.exists?(project.repository_storage, "#{project.disk_path}.git")).to be_falsey
       end
 
       it 'cleans up deleted repositories' do
         project.delete
 
         expect(::GitlabShellWorker).to receive(:perform_in)
-          .with(5.minutes, :remove_repository, project.repository_storage_path, "#{project.disk_path}+#{project.id}+deleted")
+          .with(5.minutes, :remove_repository, project.repository_storage, "#{project.disk_path}+#{project.id}+deleted")
           .and_return(true)
 
         service.execute
@@ -55,18 +55,18 @@ describe Geo::RepositoryDestroyService do
       it 'removes the repository from disk' do
         project.delete
 
-        expect(project.gitlab_shell.exists?(project.repository_storage_path, "#{project.disk_path}.git")).to be_truthy
+        expect(project.gitlab_shell.exists?(project.repository_storage, "#{project.disk_path}.git")).to be_truthy
 
         service.execute
 
-        expect(project.gitlab_shell.exists?(project.repository_storage_path, "#{project.disk_path}.git")).to be_falsey
+        expect(project.gitlab_shell.exists?(project.repository_storage, "#{project.disk_path}.git")).to be_falsey
       end
 
       it 'cleans up deleted repositories' do
         project.delete
 
         expect(::GitlabShellWorker).to receive(:perform_in)
-          .with(5.minutes, :remove_repository, project.repository_storage_path, "#{project.disk_path}+#{project.id}+deleted")
+          .with(5.minutes, :remove_repository, project.repository_storage, "#{project.disk_path}+#{project.id}+deleted")
           .and_return(true)
 
         service.execute

ee/spec/services/geo/repository_renamed_event_store_spec.rb

@@ -36,7 +36,6 @@ describe Geo::RepositoryRenamedEventStore do
         event = Geo::RepositoryRenamedEvent.last
 
         expect(event.repository_storage_name).to eq(project.repository_storage)
-        expect(event.repository_storage_path).to eq(project.repository_storage_path)
         expect(event.old_path_with_namespace).to eq(old_path_with_namespace)
         expect(event.new_path_with_namespace).to eq(project.disk_path)
         expect(event.old_wiki_path_with_namespace).to eq("#{old_path_with_namespace}.wiki")

ee/spec/services/geo/repository_sync_service_spec.rb

@@ -255,12 +255,12 @@ describe Geo::RepositorySyncService do
         expect(subject.gitlab_shell).to receive(:mv_repository).exactly(2).times.and_call_original
 
         expect(subject.gitlab_shell).to receive(:add_namespace).with(
-          project.repository_storage_path,
+          project.repository_storage,
           "@failed-geo-sync/#{File.dirname(repository.disk_path)}"
         ).and_call_original
 
         expect(subject.gitlab_shell).to receive(:add_namespace).with(
-          project.repository_storage_path,
+          project.repository_storage,
           File.dirname(repository.disk_path)
         ).and_call_original
 

ee/spec/services/projects/destroy_service_spec.rb

@@ -8,7 +8,6 @@ describe Projects::DestroyService do
   let!(:project_path) { project.disk_path }
   let!(:wiki_path) { project.wiki.disk_path }
   let!(:storage_name) { project.repository_storage }
-  let!(:storage_path) { project.repository_storage_path }
 
   subject { described_class.new(project, user, {}) }
 

ee/spec/services/projects/update_repository_storage_service_spec.rb

@@ -34,9 +34,7 @@ describe Projects::UpdateRepositoryStorageService do
           expect_any_instance_of(Gitlab::Git::Repository).to receive(:fetch_repository_as_mirror)
             .with(project.repository.raw).and_return(true)
           expect(GitlabShellWorker).to receive(:perform_async)
-            .with(:mv_repository,
-              File.absolute_path('tmp/tests/storage_a'),
-              project.disk_path,
+            .with(:mv_repository, 'a', project.disk_path,
               "#{project.disk_path}+#{project.id}+moved+#{time.to_i}")
 
           subject.execute('b')
@@ -87,17 +85,13 @@ describe Projects::UpdateRepositoryStorageService do
           expect(repository_double).to receive(:fetch_repository_as_mirror)
             .with(project.repository.raw).and_return(true)
           expect(GitlabShellWorker).to receive(:perform_async)
-            .with(:mv_repository,
-              File.absolute_path('tmp/tests/storage_a'),
-              project.disk_path,
+            .with(:mv_repository, "a", project.disk_path,
               "#{project.disk_path}+#{project.id}+moved+#{time.to_i}")
 
           expect(wiki_repository_double).to receive(:fetch_repository_as_mirror)
             .with(project.wiki.repository.raw).and_return(true)
           expect(GitlabShellWorker).to receive(:perform_async)
-            .with(:mv_repository,
-              File.absolute_path('tmp/tests/storage_a'),
-              project.wiki.disk_path,
+            .with(:mv_repository, "a", project.wiki.disk_path,
               "#{project.disk_path}+#{project.id}+moved+#{time.to_i}.wiki")
 
           subject.execute('b')

ee/spec/support/services/base_sync_service_shared_examples.rb

@@ -41,7 +41,7 @@ shared_examples 'cleans temporary repositories' do
       allow(subject).to receive(:fetch_geo_mirror)
 
       expect(gitlab_shell).to receive(:exists?).and_return(true)
-      expect(gitlab_shell).to receive(:remove_repository).with(project.repository_storage_path, temp_repo_path)
+      expect(gitlab_shell).to receive(:remove_repository).with(project.repository_storage, temp_repo_path)
 
       subject.execute
     end

ee/spec/workers/geo/repository_sync_worker_spec.rb

@@ -24,13 +24,13 @@ describe Geo::RepositorySyncWorker, :geo, :clean_gitlab_redis_cache do
   describe '#perform' do
     context 'additional shards' do
       it 'skips backfill for repositories on other shards' do
-        unhealthy_not_synced = create(:project, group: synced_group, repository_storage: 'broken')
+        create(:project, group: synced_group, repository_storage: 'broken')
         unhealthy_dirty = create(:project, group: synced_group, repository_storage: 'broken')
 
         create(:geo_project_registry, :synced, :repository_dirty, project: unhealthy_dirty)
 
         # Make the shard unhealthy
-        FileUtils.rm_rf(unhealthy_not_synced.repository_storage_path)
+        Gitlab::Shell.new.rm_directory('broken', '/')
 
         expect(Geo::RepositoryShardSyncWorker).to receive(:perform_async).with(project_in_synced_group.repository.storage)
         expect(Geo::RepositoryShardSyncWorker).not_to receive(:perform_async).with('broken')

ee/spec/workers/geo/repository_verification/primary/batch_worker_spec.rb

@@ -23,13 +23,13 @@ describe Geo::RepositoryVerification::Primary::BatchWorker, :postgresql, :clean_
       end
 
       it 'skips backfill for repositories on other shards' do
-        unhealthy_not_verified = create(:project, repository_storage: 'broken')
+        create(:project, repository_storage: 'broken')
         unhealthy_outdated = create(:project, repository_storage: 'broken')
 
         create(:repository_state, :repository_outdated, project: unhealthy_outdated)
 
         # Make the shard unhealthy
-        FileUtils.rm_rf(unhealthy_not_verified.repository_storage_path)
+        Gitlab::Shell.new.rm_directory('broken', '/')
 
         expect(Geo::RepositoryVerification::Primary::ShardWorker).to receive(:perform_async).with(healthy_shard)
         expect(Geo::RepositoryVerification::Primary::ShardWorker).not_to receive(:perform_async).with('broken')

ee/spec/workers/geo/repository_verification/secondary/scheduler_worker_spec.rb

@@ -23,10 +23,10 @@ describe Geo::RepositoryVerification::Secondary::SchedulerWorker, :postgresql, :
       end
 
       it 'skips verification for repositories on other shards' do
-        unhealthy_not_verified = create(:project, repository_storage: 'broken')
+        create(:project, repository_storage: 'broken')
 
         # Make the shard unhealthy
-        FileUtils.rm_rf(unhealthy_not_verified.repository_storage_path)
+        Gitlab::Shell.new.rm_directory('broken', '/')
 
         expect(Geo::RepositoryVerification::Secondary::ShardWorker).to receive(:perform_async).with(healthy_shard)
         expect(Geo::RepositoryVerification::Secondary::ShardWorker).not_to receive(:perform_async).with('broken')

lib/gitlab/bare_repository_import/importer.rb

@@ -75,10 +75,11 @@ module Gitlab
       end
 
       def mv_repo(project)
-        FileUtils.mv(repo_path, File.join(project.repository_storage_path, project.disk_path + '.git'))
+        storage_path = storage_path_for_shard(project.repository_storage)
+        FileUtils.mv(repo_path, project.repository.path_to_repo)
 
         if bare_repo.wiki_exists?
-          FileUtils.mv(wiki_path, File.join(project.repository_storage_path, project.disk_path + '.wiki.git'))
+          FileUtils.mv(wiki_path, File.join(storage_path, project.disk_path + '.wiki.git'))
         end
 
         true
@@ -88,6 +89,10 @@ module Gitlab
         false
       end
 
+      def storage_path_for_shard(shard)
+        Gitlab.config.repositories.storages[shard].legacy_disk_path
+      end
+
       def find_or_create_groups
         return nil unless group_path.present?
 

lib/gitlab/database/rename_reserved_paths_migration/v1/rename_namespaces.rb

@@ -62,21 +62,20 @@ module Gitlab
           end
 
           def move_repositories(namespace, old_full_path, new_full_path)
-            repo_paths_for_namespace(namespace).each do |repository_storage_path|
+            repo_shards_for_namespace(namespace).each do |repository_storage|
               # Ensure old directory exists before moving it
-              gitlab_shell.add_namespace(repository_storage_path, old_full_path)
+              gitlab_shell.add_namespace(repository_storage, old_full_path)
 
-              unless gitlab_shell.mv_namespace(repository_storage_path, old_full_path, new_full_path)
-                message = "Exception moving path #{repository_storage_path} \
-                           from #{old_full_path} to #{new_full_path}"
+              unless gitlab_shell.mv_namespace(repository_storage, old_full_path, new_full_path)
+                message = "Exception moving on shard #{repository_storage} from #{old_full_path} to #{new_full_path}"
                 Rails.logger.error message
               end
             end
           end
 
-          def repo_paths_for_namespace(namespace)
+          def repo_shards_for_namespace(namespace)
             projects_for_namespace(namespace).distinct.select(:repository_storage)
-              .map(&:repository_storage_path)
+              .map(&:repository_storage)
           end
 
           def projects_for_namespace(namespace)

lib/gitlab/database/rename_reserved_paths_migration/v1/rename_projects.rb

@@ -51,7 +51,7 @@ module Gitlab
           end
 
           def move_repository(project, old_path, new_path)
-            unless gitlab_shell.mv_repository(project.repository_storage_path,
+            unless gitlab_shell.mv_repository(project.repository_storage,
                                               old_path,
                                               new_path)
               Rails.logger.error "Error moving #{old_path} to #{new_path}"

lib/gitlab/shell.rb

@@ -65,11 +65,11 @@ module Gitlab
 
     # Init new repository
     #
-    # storage - project's storage name
+    # storage - the shard key
     # name - project disk path
     #
     # Ex.
-    #   create_repository("/path/to/storage", "gitlab/gitlab-ci")
+    #   create_repository("default", "gitlab/gitlab-ci")
     #
     def create_repository(storage, name)
       relative_path = name.dup
@@ -291,13 +291,13 @@ module Gitlab
     # Add empty directory for storing repositories
     #
     # Ex.
-    #   add_namespace("/path/to/storage", "gitlab")
+    #   add_namespace("default", "gitlab")
     #
     def add_namespace(storage, name)
       Gitlab::GitalyClient.migrate(:add_namespace,
                                    status: Gitlab::GitalyClient::MigrationStatus::OPT_OUT) do |enabled|
         if enabled
-          gitaly_namespace_client(storage).add(name)
+          Gitlab::GitalyClient::NamespaceService.new(storage).add(name)
         else
           path = full_path(storage, name)
           FileUtils.mkdir_p(path, mode: 0770) unless exists?(storage, name)
@@ -313,13 +313,13 @@ module Gitlab
     # Every repository inside this directory will be removed too
     #
     # Ex.
-    #   rm_namespace("/path/to/storage", "gitlab")
+    #   rm_namespace("default", "gitlab")
     #
     def rm_namespace(storage, name)
       Gitlab::GitalyClient.migrate(:remove_namespace,
                                status: Gitlab::GitalyClient::MigrationStatus::OPT_OUT) do |enabled|
         if enabled
-          gitaly_namespace_client(storage).remove(name)
+          Gitlab::GitalyClient::NamespaceService.new(storage).remove(name)
         else
           FileUtils.rm_r(full_path(storage, name), force: true)
         end
@@ -338,7 +338,8 @@ module Gitlab
       Gitlab::GitalyClient.migrate(:rename_namespace,
                                    status: Gitlab::GitalyClient::MigrationStatus::OPT_OUT) do |enabled|
         if enabled
-          gitaly_namespace_client(storage).rename(old_name, new_name)
+          Gitlab::GitalyClient::NamespaceService.new(storage)
+            .rename(old_name, new_name)
         else
           break false if exists?(storage, new_name) || !exists?(storage, old_name)
 
@@ -374,7 +375,8 @@ module Gitlab
       Gitlab::GitalyClient.migrate(:namespace_exists,
                                    status: Gitlab::GitalyClient::MigrationStatus::OPT_OUT) do |enabled|
         if enabled
-          gitaly_namespace_client(storage).exists?(dir_name)
+          Gitlab::GitalyClient::NamespaceService.new(storage)
+            .exists?(dir_name)
         else
           File.exist?(full_path(storage, dir_name))
         end
@@ -398,7 +400,7 @@ module Gitlab
     def full_path(storage, dir_name)
       raise ArgumentError.new("Directory name can't be blank") if dir_name.blank?
 
-      File.join(storage, dir_name)
+      File.join(Gitlab.config.repositories.storages[storage].legacy_disk_path, dir_name)
     end
 
     def gitlab_shell_projects_path
@@ -475,14 +477,6 @@ module Gitlab
       Bundler.with_original_env { Popen.popen(cmd, nil, vars) }
     end
 
-    def gitaly_namespace_client(storage_path)
-      storage, _value = Gitlab.config.repositories.storages.find do |storage, value|
-        value.legacy_disk_path == storage_path
-      end
-
-      Gitlab::GitalyClient::NamespaceService.new(storage)
-    end
-
     def git_timeout
       Gitlab.config.gitlab_shell.git_timeout
     end

lib/tasks/gitlab/check.rake

@@ -430,10 +430,7 @@ namespace :gitlab do
       user = User.find_by(username: username)
       if user
         repo_dirs = user.authorized_projects.map do |p|
-          File.join(
-            p.repository_storage_path,
-            "#{p.disk_path}.git"
-          )
+          p.repository.path_to_repo
         end
 
         repo_dirs.each { |repo_dir| check_repo_integrity(repo_dir) }

lib/tasks/gitlab/list_repos.rake

@@ -10,9 +10,8 @@ namespace :gitlab do
     end
 
     scope.find_each do |project|
-      base = File.join(project.repository_storage_path, project.disk_path)
-      puts base + '.git'
-      puts base + '.wiki.git'
+      puts project.repository.path_to_repo
+      puts project.wiki.repository.path_to_repo
     end
   end
 end

spec/controllers/profiles_controller_spec.rb

@@ -125,7 +125,7 @@ describe ProfilesController, :request_store do
         user.reload
 
         expect(response.status).to eq(302)
-        expect(gitlab_shell.exists?(project.repository_storage_path, "#{new_username}/#{project.path}.git")).to be_truthy
+        expect(gitlab_shell.exists?(project.repository_storage, "#{new_username}/#{project.path}.git")).to be_truthy
       end
     end
 
@@ -143,7 +143,7 @@ describe ProfilesController, :request_store do
         user.reload
 
         expect(response.status).to eq(302)
-        expect(gitlab_shell.exists?(project.repository_storage_path, "#{project.disk_path}.git")).to be_truthy
+        expect(gitlab_shell.exists?(project.repository_storage, "#{project.disk_path}.git")).to be_truthy
         expect(before_disk_path).to eq(project.disk_path)
       end
     end

spec/factories/projects.rb

@@ -179,7 +179,8 @@ FactoryBot.define do
 
         # We delete hooks so that gitlab-shell will not try to authenticate with
         # an API that isn't running
-        FileUtils.rm_r(File.join(project.repository_storage_path, "#{project.disk_path}.git", 'hooks'))
+        project.gitlab_shell.rm_directory(project.repository_storage,
+                                          File.join("#{project.disk_path}.git", 'hooks'))
       end
     end
 
@@ -209,7 +210,8 @@ FactoryBot.define do
       after(:create) do |project|
         raise "Failed to create repository!" unless project.create_repository
 
-        FileUtils.rm_r(File.join(project.repository_storage_path, "#{project.disk_path}.git", 'refs'))
+        project.gitlab_shell.rm_directory(project.repository_storage,
+                                          File.join("#{project.disk_path}.git", 'refs'))
       end
     end
 

spec/helpers/projects_helper_spec.rb

@@ -283,16 +283,16 @@ describe ProjectsHelper do
     end
   end
 
-  describe '#sanitized_import_error' do
+  describe '#sanitized_repo_path' do
     let(:project) { create(:project, :repository) }
+    let(:storage_path) { Gitlab.config.repositories.storages.default.legacy_disk_path }
 
     before do
-      allow(project).to receive(:repository_storage_path).and_return('/base/repo/path')
       allow(Settings.shared).to receive(:[]).with('path').and_return('/base/repo/export/path')
     end
 
     it 'removes the repo path' do
-      repo = '/base/repo/path/namespace/test.git'
+      repo = "#{storage_path}/namespace/test.git"
       import_error = "Could not clone #{repo}\n"
 
       expect(sanitize_repo_path(project, import_error)).to eq('Could not clone [REPOS PATH]/namespace/test.git')

spec/lib/gitlab/bare_repository_import/importer_spec.rb

@@ -4,6 +4,7 @@ describe Gitlab::BareRepositoryImport::Importer, repository: true do
   let!(:admin) { create(:admin) }
   let!(:base_dir) { Dir.mktmpdir + '/' }
   let(:bare_repository) { Gitlab::BareRepositoryImport::Repository.new(base_dir, File.join(base_dir, "#{project_path}.git")) }
+  let(:gitlab_shell) { Gitlab::Shell.new }
 
   subject(:importer) { described_class.new(admin, bare_repository) }
 
@@ -84,12 +85,14 @@ describe Gitlab::BareRepositoryImport::Importer, repository: true do
         importer.create_project_if_needed
 
         project = Project.find_by_full_path(project_path)
-        repo_path = File.join(project.repository_storage_path, project.disk_path + '.git')
+        repo_path = "#{project.disk_path}.git"
         hook_path = File.join(repo_path, 'hooks')
 
-        expect(File).to exist(repo_path)
-        expect(File.symlink?(hook_path)).to be true
-        expect(File.readlink(hook_path)).to eq(Gitlab.config.gitlab_shell.hooks_path)
+        expect(gitlab_shell.exists?(project.repository_storage, repo_path)).to be(true)
+        expect(gitlab_shell.exists?(project.repository_storage, hook_path)).to be(true)
+
+        full_hook_path = File.join(project.repository.path_to_repo, 'hooks')
+        expect(File.readlink(full_hook_path)).to eq(Gitlab.config.gitlab_shell.hooks_path)
       end
 
       context 'hashed storage enabled' do
@@ -144,8 +147,8 @@ describe Gitlab::BareRepositoryImport::Importer, repository: true do
 
       project = Project.find_by_full_path("#{admin.full_path}/#{project_path}")
 
-      expect(File).to exist(File.join(project.repository_storage_path, project.disk_path + '.git'))
-      expect(File).to exist(File.join(project.repository_storage_path, project.disk_path + '.wiki.git'))
+      expect(gitlab_shell.exists?(project.repository_storage, project.disk_path + '.git')).to be(true)
+      expect(gitlab_shell.exists?(project.repository_storage, project.disk_path + '.wiki.git')).to be(true)
     end
 
     it 'moves an existing project to the correct path' do
@@ -155,7 +158,9 @@ describe Gitlab::BareRepositoryImport::Importer, repository: true do
       project = build(:project, :legacy_storage, :repository)
       original_commit_count = project.repository.commit_count
 
-      bare_repo = Gitlab::BareRepositoryImport::Repository.new(project.repository_storage_path, project.repository.path)
+      legacy_path = Gitlab.config.repositories.storages[project.repository_storage].legacy_disk_path
+
+      bare_repo = Gitlab::BareRepositoryImport::Repository.new(legacy_path, project.repository.path)
       gitlab_importer = described_class.new(admin, bare_repo)
 
       expect(gitlab_importer).to receive(:create_project).and_call_original
@@ -183,7 +188,7 @@ describe Gitlab::BareRepositoryImport::Importer, repository: true do
 
       project = Project.find_by_full_path(project_path)
 
-      expect(File).to exist(File.join(project.repository_storage_path, project.disk_path + '.wiki.git'))
+      expect(gitlab_shell.exists?(project.repository_storage, project.disk_path + '.wiki.git')).to be(true)
     end
   end
 

spec/lib/gitlab/bare_repository_import/repository_spec.rb

@@ -67,7 +67,7 @@ describe ::Gitlab::BareRepositoryImport::Repository do
     end
 
     after do
-      gitlab_shell.remove_repository(root_path, hashed_path)
+      gitlab_shell.remove_repository(repository_storage, hashed_path)
     end
 
     subject { described_class.new(root_path, repo_path) }

spec/lib/gitlab/git/repository_spec.rb

@@ -689,7 +689,7 @@ describe Gitlab::Git::Repository, seed_helper: true do
     end
 
     after do
-      Gitlab::Shell.new.remove_repository(storage_path, 'my_project')
+      Gitlab::Shell.new.remove_repository('default', 'my_project')
     end
 
     shared_examples 'repository mirror fecthing' do

spec/lib/gitlab/import_export/wiki_restorer_spec.rb

@@ -24,8 +24,8 @@ describe Gitlab::ImportExport::WikiRestorer do
 
     after do
       FileUtils.rm_rf(export_path)
-      Gitlab::Shell.new.remove_repository(project_with_wiki.wiki.repository_storage_path, project_with_wiki.wiki.disk_path)
-      Gitlab::Shell.new.remove_repository(project.wiki.repository_storage_path, project.wiki.disk_path)
+      Gitlab::Shell.new.remove_repository(project_with_wiki.wiki.repository_storage, project_with_wiki.wiki.disk_path)
+      Gitlab::Shell.new.remove_repository(project.wiki.repository_storage, project.wiki.disk_path)
     end
 
     it 'restores the wiki repo successfully' do

spec/lib/gitlab/shell_spec.rb

@@ -447,18 +447,18 @@ describe Gitlab::Shell do
       let(:disk_path) { "#{project.disk_path}.git" }
 
       it 'returns true when the command succeeds' do
-        expect(gitlab_shell.exists?(project.repository_storage_path, disk_path)).to be(true)
+        expect(gitlab_shell.exists?(project.repository_storage, disk_path)).to be(true)
 
-        expect(gitlab_shell.remove_repository(project.repository_storage_path, project.disk_path)).to be(true)
+        expect(gitlab_shell.remove_repository(project.repository_storage, project.disk_path)).to be(true)
 
-        expect(gitlab_shell.exists?(project.repository_storage_path, disk_path)).to be(false)
+        expect(gitlab_shell.exists?(project.repository_storage, disk_path)).to be(false)
       end
 
       it 'keeps the namespace directory' do
-        gitlab_shell.remove_repository(project.repository_storage_path, project.disk_path)
+        gitlab_shell.remove_repository(project.repository_storage, project.disk_path)
 
-        expect(gitlab_shell.exists?(project.repository_storage_path, disk_path)).to be(false)
-        expect(gitlab_shell.exists?(project.repository_storage_path, project.disk_path.gsub(project.name, ''))).to be(true)
+        expect(gitlab_shell.exists?(project.repository_storage, disk_path)).to be(false)
+        expect(gitlab_shell.exists?(project.repository_storage, project.disk_path.gsub(project.name, ''))).to be(true)
       end
     end
 
@@ -469,18 +469,18 @@ describe Gitlab::Shell do
         old_path = project2.disk_path
         new_path = "project/new_path"
 
-        expect(gitlab_shell.exists?(project2.repository_storage_path, "#{old_path}.git")).to be(true)
-        expect(gitlab_shell.exists?(project2.repository_storage_path, "#{new_path}.git")).to be(false)
+        expect(gitlab_shell.exists?(project2.repository_storage, "#{old_path}.git")).to be(true)
+        expect(gitlab_shell.exists?(project2.repository_storage, "#{new_path}.git")).to be(false)
 
-        expect(gitlab_shell.mv_repository(project2.repository_storage_path, old_path, new_path)).to be_truthy
+        expect(gitlab_shell.mv_repository(project2.repository_storage, old_path, new_path)).to be_truthy
 
-        expect(gitlab_shell.exists?(project2.repository_storage_path, "#{old_path}.git")).to be(false)
-        expect(gitlab_shell.exists?(project2.repository_storage_path, "#{new_path}.git")).to be(true)
+        expect(gitlab_shell.exists?(project2.repository_storage, "#{old_path}.git")).to be(false)
+        expect(gitlab_shell.exists?(project2.repository_storage, "#{new_path}.git")).to be(true)
       end
 
       it 'returns false when the command fails' do
-        expect(gitlab_shell.mv_repository(project2.repository_storage_path, project2.disk_path, '')).to be_falsy
-        expect(gitlab_shell.exists?(project2.repository_storage_path, "#{project2.disk_path}.git")).to be(true)
+        expect(gitlab_shell.mv_repository(project2.repository_storage, project2.disk_path, '')).to be_falsy
+        expect(gitlab_shell.exists?(project2.repository_storage, "#{project2.disk_path}.git")).to be(true)
       end
     end
 
@@ -679,48 +679,48 @@ describe Gitlab::Shell do
 
   describe 'namespace actions' do
     subject { described_class.new }
-    let(:storage_path) { Gitlab.config.repositories.storages.default.legacy_disk_path }
+    let(:storage) { Gitlab.config.repositories.storages.keys.first }
 
     describe '#add_namespace' do
       it 'creates a namespace' do
-        subject.add_namespace(storage_path, "mepmep")
+        subject.add_namespace(storage, "mepmep")
 
-        expect(subject.exists?(storage_path, "mepmep")).to be(true)
+        expect(subject.exists?(storage, "mepmep")).to be(true)
       end
     end
 
     describe '#exists?' do
       context 'when the namespace does not exist' do
         it 'returns false' do
-          expect(subject.exists?(storage_path, "non-existing")).to be(false)
+          expect(subject.exists?(storage, "non-existing")).to be(false)
         end
       end
 
       context 'when the namespace exists' do
         it 'returns true' do
-          subject.add_namespace(storage_path, "mepmep")
+          subject.add_namespace(storage, "mepmep")
 
-          expect(subject.exists?(storage_path, "mepmep")).to be(true)
+          expect(subject.exists?(storage, "mepmep")).to be(true)
         end
       end
     end
 
     describe '#remove' do
       it 'removes the namespace' do
-        subject.add_namespace(storage_path, "mepmep")
-        subject.rm_namespace(storage_path, "mepmep")
+        subject.add_namespace(storage, "mepmep")
+        subject.rm_namespace(storage, "mepmep")
 
-        expect(subject.exists?(storage_path, "mepmep")).to be(false)
+        expect(subject.exists?(storage, "mepmep")).to be(false)
       end
     end
 
     describe '#mv_namespace' do
       it 'renames the namespace' do
-        subject.add_namespace(storage_path, "mepmep")
-        subject.mv_namespace(storage_path, "mepmep", "2mep")
+        subject.add_namespace(storage, "mepmep")
+        subject.mv_namespace(storage, "mepmep", "2mep")
 
-        expect(subject.exists?(storage_path, "mepmep")).to be(false)
-        expect(subject.exists?(storage_path, "2mep")).to be(true)
+        expect(subject.exists?(storage, "mepmep")).to be(false)
+        expect(subject.exists?(storage, "2mep")).to be(true)
       end
     end
   end

spec/models/namespace_spec.rb

@@ -5,6 +5,7 @@ describe Namespace do
 
   let!(:namespace) { create(:namespace) }
   let(:gitlab_shell) { Gitlab::Shell.new }
+  let(:repository_storage) { 'default' }
 
   describe 'associations' do
     it { is_expected.to have_many :projects }
@@ -201,7 +202,7 @@ describe Namespace do
       it "moves dir if path changed" do
         namespace.update_attributes(path: namespace.full_path + '_new')
 
-        expect(gitlab_shell.exists?(project.repository_storage_path, "#{namespace.path}/#{project.path}.git")).to be_truthy
+        expect(gitlab_shell.exists?(project.repository_storage, "#{namespace.path}/#{project.path}.git")).to be_truthy
       end
 
       context 'with subgroups', :nested_groups do
@@ -281,7 +282,7 @@ describe Namespace do
         namespace.update_attributes(path: namespace.full_path + '_new')
 
         expect(before_disk_path).to eq(project.disk_path)
-        expect(gitlab_shell.exists?(project.repository_storage_path, "#{project.disk_path}.git")).to be_truthy
+        expect(gitlab_shell.exists?(project.repository_storage, "#{project.disk_path}.git")).to be_truthy
       end
     end
 
@@ -334,7 +335,7 @@ describe Namespace do
       end
 
       it 'schedules the namespace for deletion' do
-        expect(GitlabShellWorker).to receive(:perform_in).with(5.minutes, :rm_namespace, repository_storage_path, deleted_path)
+        expect(GitlabShellWorker).to receive(:perform_in).with(5.minutes, :rm_namespace, repository_storage, deleted_path)
 
         namespace.destroy
       end
@@ -356,7 +357,7 @@ describe Namespace do
         end
 
         it 'schedules the namespace for deletion' do
-          expect(GitlabShellWorker).to receive(:perform_in).with(5.minutes, :rm_namespace, repository_storage_path, deleted_path)
+          expect(GitlabShellWorker).to receive(:perform_in).with(5.minutes, :rm_namespace, repository_storage, deleted_path)
 
           child.destroy
         end

spec/models/project_spec.rb

@@ -479,14 +479,6 @@ describe Project do
     end
   end
 
-  describe '#repository_storage_path' do
-    let(:project) { create(:project) }
-
-    it 'returns the repository storage path' do
-      expect(Dir.exist?(project.repository_storage_path)).to be(true)
-    end
-  end
-
   it 'returns valid url to repo' do
     project = described_class.new(path: 'somewhere')
     expect(project.url_to_repo).to eq(Gitlab.config.gitlab_shell.ssh_path_prefix + 'somewhere.git')
@@ -1232,7 +1224,7 @@ describe Project do
   end
 
   context 'repository storage by default' do
-    let(:project) { create(:project) }
+    let(:project) { build(:project) }
 
     before do
       storages = {
@@ -1585,7 +1577,7 @@ describe Project do
         .and_return(false)
 
       allow(shell).to receive(:create_repository)
-        .with(project.repository_storage_path, project.disk_path)
+        .with(project.repository_storage, project.disk_path)
         .and_return(true)
 
       expect(project).to receive(:create_repository).with(force: true)
@@ -3040,7 +3032,7 @@ describe Project do
 
     describe '#ensure_storage_path_exists' do
       it 'delegates to gitlab_shell to ensure namespace is created' do
-        expect(gitlab_shell).to receive(:add_namespace).with(project.repository_storage_path, project.base_dir)
+        expect(gitlab_shell).to receive(:add_namespace).with(project.repository_storage, project.base_dir)
 
         project.ensure_storage_path_exists
       end
@@ -3079,12 +3071,12 @@ describe Project do
 
         expect(gitlab_shell).to receive(:mv_repository)
           .ordered
-          .with(project.repository_storage_path, "#{project.namespace.full_path}/foo", "#{project.full_path}")
+          .with(project.repository_storage, "#{project.namespace.full_path}/foo", "#{project.full_path}")
           .and_return(true)
 
         expect(gitlab_shell).to receive(:mv_repository)
           .ordered
-          .with(project.repository_storage_path, "#{project.namespace.full_path}/foo.wiki", "#{project.full_path}.wiki")
+          .with(project.repository_storage, "#{project.namespace.full_path}/foo.wiki", "#{project.full_path}.wiki")
           .and_return(true)
 
         expect_any_instance_of(SystemHooksService)
@@ -3233,7 +3225,7 @@ describe Project do
       it 'delegates to gitlab_shell to ensure namespace is created' do
         allow(project).to receive(:gitlab_shell).and_return(gitlab_shell)
 
-        expect(gitlab_shell).to receive(:add_namespace).with(project.repository_storage_path, hashed_prefix)
+        expect(gitlab_shell).to receive(:add_namespace).with(project.repository_storage, hashed_prefix)
 
         project.ensure_storage_path_exists
       end

spec/models/project_wiki_spec.rb

@@ -11,7 +11,7 @@ describe ProjectWiki do
   subject { project_wiki }
 
   it { is_expected.to delegate_method(:empty?).to :pages }
-  it { is_expected.to delegate_method(:repository_storage_path).to :project }
+  it { is_expected.to delegate_method(:repository_storage).to :project }
   it { is_expected.to delegate_method(:hashed_storage?).to :project }
 
   describe "#full_path" do

spec/services/groups/destroy_service_spec.rb

@@ -53,8 +53,8 @@ describe Groups::DestroyService do
         end
 
         it 'verifies that paths have been deleted' do
-          expect(gitlab_shell.exists?(project.repository_storage_path, group.path)).to be_falsey
-          expect(gitlab_shell.exists?(project.repository_storage_path, remove_path)).to be_falsey
+          expect(gitlab_shell.exists?(project.repository_storage, group.path)).to be_falsey
+          expect(gitlab_shell.exists?(project.repository_storage, remove_path)).to be_falsey
         end
       end
     end
@@ -71,13 +71,13 @@ describe Groups::DestroyService do
 
       after do
         # Clean up stale directories
-        gitlab_shell.rm_namespace(project.repository_storage_path, group.path)
-        gitlab_shell.rm_namespace(project.repository_storage_path, remove_path)
+        gitlab_shell.rm_namespace(project.repository_storage, group.path)
+        gitlab_shell.rm_namespace(project.repository_storage, remove_path)
       end
 
       it 'verifies original paths and projects still exist' do
-        expect(gitlab_shell.exists?(project.repository_storage_path, group.path)).to be_truthy
-        expect(gitlab_shell.exists?(project.repository_storage_path, remove_path)).to be_falsey
+        expect(gitlab_shell.exists?(project.repository_storage, group.path)).to be_truthy
+        expect(gitlab_shell.exists?(project.repository_storage, remove_path)).to be_falsey
         expect(Project.unscoped.count).to eq(1)
         expect(Group.unscoped.count).to eq(2)
       end
@@ -106,7 +106,7 @@ describe Groups::DestroyService do
       let!(:project) { create(:project, :legacy_storage, :empty_repo, namespace: group) }
 
       it 'removes repository' do
-        expect(gitlab_shell.exists?(project.repository_storage_path, "#{project.disk_path}.git")).to be_falsey
+        expect(gitlab_shell.exists?(project.repository_storage, "#{project.disk_path}.git")).to be_falsey
       end
     end
 
@@ -114,7 +114,7 @@ describe Groups::DestroyService do
       let!(:project) { create(:project, :empty_repo, namespace: group) }
 
       it 'removes repository' do
-        expect(gitlab_shell.exists?(project.repository_storage_path, "#{project.disk_path}.git")).to be_falsey
+        expect(gitlab_shell.exists?(project.repository_storage, "#{project.disk_path}.git")).to be_falsey
       end
     end
   end

spec/services/projects/create_service_spec.rb

@@ -171,7 +171,6 @@ describe Projects::CreateService, '#execute' do
 
     context 'when another repository already exists on disk' do
       let(:repository_storage) { 'default' }
-      let(:repository_storage_path) { Gitlab.config.repositories.storages[repository_storage].legacy_disk_path }
 
       let(:opts) do
         {
@@ -186,7 +185,7 @@ describe Projects::CreateService, '#execute' do
         end
 
         after do
-          gitlab_shell.remove_repository(repository_storage_path, "#{user.namespace.full_path}/existing")
+          gitlab_shell.remove_repository(repository_storage, "#{user.namespace.full_path}/existing")
         end
 
         it 'does not allow to create a project when path matches existing repository on disk' do
@@ -222,7 +221,7 @@ describe Projects::CreateService, '#execute' do
         end
 
         after do
-          gitlab_shell.remove_repository(repository_storage_path, hashed_path)
+          gitlab_shell.remove_repository(repository_storage, hashed_path)
         end
 
         it 'does not allow to create a project when path matches existing repository on disk' do

spec/services/projects/destroy_service_spec.rb

@@ -18,8 +18,8 @@ describe Projects::DestroyService do
     it 'deletes the project' do
       expect(Project.unscoped.all).not_to include(project)
 
-      expect(project.gitlab_shell.exists?(project.repository_storage_path, path + '.git')).to be_falsey
-      expect(project.gitlab_shell.exists?(project.repository_storage_path, remove_path + '.git')).to be_falsey
+      expect(project.gitlab_shell.exists?(project.repository_storage, path + '.git')).to be_falsey
+      expect(project.gitlab_shell.exists?(project.repository_storage, remove_path + '.git')).to be_falsey
     end
   end
 
@@ -265,21 +265,21 @@ describe Projects::DestroyService do
     let(:path) { project.disk_path + '.git' }
 
     before do
-      expect(project.gitlab_shell.exists?(project.repository_storage_path, path)).to be_truthy
-      expect(project.gitlab_shell.exists?(project.repository_storage_path, remove_path)).to be_falsey
+      expect(project.gitlab_shell.exists?(project.repository_storage, path)).to be_truthy
+      expect(project.gitlab_shell.exists?(project.repository_storage, remove_path)).to be_falsey
 
       # Dont run sidekiq to check if renamed repository exists
       Sidekiq::Testing.fake! { destroy_project(project, user, {}) }
 
-      expect(project.gitlab_shell.exists?(project.repository_storage_path, path)).to be_falsey
-      expect(project.gitlab_shell.exists?(project.repository_storage_path, remove_path)).to be_truthy
+      expect(project.gitlab_shell.exists?(project.repository_storage, path)).to be_falsey
+      expect(project.gitlab_shell.exists?(project.repository_storage, remove_path)).to be_truthy
     end
 
     it 'restores the repositories' do
       Sidekiq::Testing.fake! { described_class.new(project, user).attempt_repositories_rollback }
 
-      expect(project.gitlab_shell.exists?(project.repository_storage_path, path)).to be_truthy
-      expect(project.gitlab_shell.exists?(project.repository_storage_path, remove_path)).to be_falsey
+      expect(project.gitlab_shell.exists?(project.repository_storage, path)).to be_truthy
+      expect(project.gitlab_shell.exists?(project.repository_storage, remove_path)).to be_falsey
     end
   end
 

spec/services/projects/fork_service_spec.rb

@@ -112,7 +112,7 @@ describe Projects::ForkService do
         end
 
         after do
-          gitlab_shell.remove_repository(repository_storage_path, "#{@to_user.namespace.full_path}/#{@from_project.path}")
+          gitlab_shell.remove_repository(repository_storage, "#{@to_user.namespace.full_path}/#{@from_project.path}")
         end
 
         it 'does not allow creation' do

spec/services/projects/hashed_storage/migrate_repository_service_spec.rb

@@ -16,8 +16,8 @@ describe Projects::HashedStorage::MigrateRepositoryService do
       it 'renames project and wiki repositories' do
         service.execute
 
-        expect(gitlab_shell.exists?(project.repository_storage_path, "#{hashed_storage.disk_path}.git")).to be_truthy
-        expect(gitlab_shell.exists?(project.repository_storage_path, "#{hashed_storage.disk_path}.wiki.git")).to be_truthy
+        expect(gitlab_shell.exists?(project.repository_storage, "#{hashed_storage.disk_path}.git")).to be_truthy
+        expect(gitlab_shell.exists?(project.repository_storage, "#{hashed_storage.disk_path}.wiki.git")).to be_truthy
       end
 
       it 'updates project to be hashed and not read-only' do
@@ -52,8 +52,8 @@ describe Projects::HashedStorage::MigrateRepositoryService do
 
         service.execute
 
-        expect(gitlab_shell.exists?(project.repository_storage_path, "#{hashed_storage.disk_path}.git")).to be_falsey
-        expect(gitlab_shell.exists?(project.repository_storage_path, "#{hashed_storage.disk_path}.wiki.git")).to be_falsey
+        expect(gitlab_shell.exists?(project.repository_storage, "#{hashed_storage.disk_path}.git")).to be_falsey
+        expect(gitlab_shell.exists?(project.repository_storage, "#{hashed_storage.disk_path}.wiki.git")).to be_falsey
         expect(project.repository_read_only?).to be_falsey
       end
 
@@ -63,11 +63,11 @@ describe Projects::HashedStorage::MigrateRepositoryService do
 
         before do
           hashed_storage.ensure_storage_path_exists
-          gitlab_shell.mv_repository(project.repository_storage_path, from_name, to_name)
+          gitlab_shell.mv_repository(project.repository_storage, from_name, to_name)
         end
 
         it 'does not try to move nil repository over hashed' do
-          expect(gitlab_shell).not_to receive(:mv_repository).with(project.repository_storage_path, from_name, to_name)
+          expect(gitlab_shell).not_to receive(:mv_repository).with(project.repository_storage, from_name, to_name)
           expect_move_repository("#{project.disk_path}.wiki", "#{hashed_storage.disk_path}.wiki")
 
           service.execute
@@ -76,7 +76,7 @@ describe Projects::HashedStorage::MigrateRepositoryService do
     end
 
     def expect_move_repository(from_name, to_name)
-      expect(gitlab_shell).to receive(:mv_repository).with(project.repository_storage_path, from_name, to_name).and_call_original
+      expect(gitlab_shell).to receive(:mv_repository).with(project.repository_storage, from_name, to_name).and_call_original
     end
   end
 end

spec/services/projects/transfer_service_spec.rb

@@ -84,7 +84,7 @@ describe Projects::TransferService do
     end
 
     def project_path(project)
-      File.join(project.repository_storage_path, "#{project.disk_path}.git")
+      project.repository.path_to_repo
     end
 
     def current_path
@@ -94,7 +94,7 @@ describe Projects::TransferService do
     it 'rolls back repo location' do
       attempt_project_transfer
 
-      expect(Dir.exist?(original_path)).to be_truthy
+      expect(gitlab_shell.exists?(project.repository_storage, "#{project.disk_path}.git")).to be(true)
       expect(original_path).to eq current_path
     end
 
@@ -165,7 +165,7 @@ describe Projects::TransferService do
     end
 
     after do
-      gitlab_shell.remove_repository(repository_storage_path, "#{group.full_path}/#{project.path}")
+      gitlab_shell.remove_repository(repository_storage, "#{group.full_path}/#{project.path}")
     end
 
     it { expect(@result).to eq false }

spec/services/projects/update_service_spec.rb

@@ -201,7 +201,7 @@ describe Projects::UpdateService, '#execute' do
         end
 
         after do
-          gitlab_shell.remove_repository(repository_storage_path, "#{user.namespace.full_path}/existing")
+          gitlab_shell.remove_repository(repository_storage, "#{user.namespace.full_path}/existing")
         end
 
         it 'does not allow renaming when new path matches existing repository on disk' do
@@ -319,22 +319,20 @@ describe Projects::UpdateService, '#execute' do
   describe 'repository_storage' do
     let(:admin_user) { create(:user, admin: true) }
     let(:user) { create(:user) }
-    let(:project) { create(:project, :repository, repository_storage: 'a') }
+    let(:project) { create(:project, :repository) }
     let(:opts) { { repository_storage: 'b' } }
 
     before do
-      FileUtils.mkdir('tmp/tests/storage_a')
       FileUtils.mkdir('tmp/tests/storage_b')
 
       storages = {
-        'a' => { 'path' => 'tmp/tests/storage_a' },
+        'default' => Gitlab.config.repositories.storages.default,
         'b' => { 'path' => 'tmp/tests/storage_b' }
       }
       stub_storage_settings(storages)
     end
 
     after do
-      FileUtils.rm_rf('tmp/tests/storage_a')
       FileUtils.rm_rf('tmp/tests/storage_b')
     end
 

spec/services/users/destroy_service_spec.rb

@@ -176,7 +176,7 @@ describe Users::DestroyService do
         let!(:project) { create(:project, :empty_repo, :legacy_storage, namespace: user.namespace) }
 
         it 'removes repository' do
-          expect(gitlab_shell.exists?(project.repository_storage_path, "#{project.disk_path}.git")).to be_falsey
+          expect(gitlab_shell.exists?(project.repository_storage, "#{project.disk_path}.git")).to be_falsey
         end
       end
 
@@ -184,7 +184,7 @@ describe Users::DestroyService do
         let!(:project) { create(:project, :empty_repo, namespace: user.namespace) }
 
         it 'removes repository' do
-          expect(gitlab_shell.exists?(project.repository_storage_path, "#{project.disk_path}.git")).to be_falsey
+          expect(gitlab_shell.exists?(project.repository_storage, "#{project.disk_path}.git")).to be_falsey
         end
       end
     end

spec/spec_helper.rb

@@ -132,10 +132,10 @@ RSpec.configure do |config|
       m.call(*args)
 
       shard_name, repository_relative_path = args
-      shard_path = Gitlab.config.repositories.storages.fetch(shard_name).legacy_disk_path
       # We can't leave the hooks in place after a fork, as those would fail in tests
       # The "internal" API is not available
-      FileUtils.rm_rf(File.join(shard_path, repository_relative_path, 'hooks'))
+      Gitlab::Shell.new.rm_directory(shard_name,
+                                     File.join(repository_relative_path, 'hooks'))
     end
 
     # Enable all features by default for testing

spec/support/helpers/javascript_fixtures_helpers.rb

@@ -31,7 +31,7 @@ module JavaScriptFixturesHelpers
   end
 
   def remove_repository(project)
-    Gitlab::Shell.new.remove_repository(project.repository_storage_path, project.disk_path)
+    Gitlab::Shell.new.remove_repository(project.repository_storage, project.disk_path)
   end
 
   private

spec/support/helpers/test_env.rb

@@ -219,7 +219,8 @@ module TestEnv
   end
 
   def copy_repo(project, bare_repo:, refs:)
-    target_repo_path = File.expand_path(project.repository_storage_path + "/#{project.disk_path}.git")
+    target_repo_path = File.expand_path(repos_path + "/#{project.disk_path}.git")
+
     FileUtils.mkdir_p(target_repo_path)
     FileUtils.cp_r("#{File.expand_path(bare_repo)}/.", target_repo_path)
     FileUtils.chmod_R 0755, target_repo_path
@@ -227,7 +228,7 @@ module TestEnv
   end
 
   def repos_path
-    Gitlab.config.repositories.storages[REPOS_STORAGE].legacy_disk_path
+    @repos_path ||= Gitlab.config.repositories.storages[REPOS_STORAGE].legacy_disk_path
   end
 
   def backup_path

spec/tasks/gitlab/backup_rake_spec.rb

@@ -195,15 +195,12 @@ describe 'gitlab:app namespace rake task' do
     end
 
     context 'multiple repository storages' do
-      let(:storage_default) do
-        Gitlab::GitalyClient::StorageSettings.new(@default_storage_hash.merge('path' => 'tmp/tests/default_storage'))
-      end
       let(:test_second_storage) do
         Gitlab::GitalyClient::StorageSettings.new(@default_storage_hash.merge('path' => 'tmp/tests/custom_storage'))
       end
       let(:storages) do
         {
-          'default' => storage_default,
+          'default' => Gitlab.config.repositories.storages.default,
           'test_second_storage' => test_second_storage
         }
       end
@@ -215,8 +212,7 @@ describe 'gitlab:app namespace rake task' do
       before do
         # We only need a backup of the repositories for this test
         stub_env('SKIP', 'db,uploads,builds,artifacts,lfs,registry')
-        FileUtils.mkdir(Settings.absolute('tmp/tests/default_storage'))
-        FileUtils.mkdir(Settings.absolute('tmp/tests/custom_storage'))
+
         allow(Gitlab.config.repositories).to receive(:storages).and_return(storages)
 
         # Avoid asking gitaly about the root ref (which will fail beacuse of the
@@ -225,14 +221,23 @@ describe 'gitlab:app namespace rake task' do
       end
 
       after do
-        FileUtils.rm_rf(Settings.absolute('tmp/tests/default_storage'))
         FileUtils.rm_rf(Settings.absolute('tmp/tests/custom_storage'))
       end
 
       it 'includes repositories in all repository storages' do
-        project_a = create(:project, :repository, repository_storage: 'default')
+        project_a = create(:project, :repository)
         project_b = create(:project, :repository, repository_storage: 'test_second_storage')
 
+        b_storage_dir = File.join(Settings.absolute('tmp/tests/custom_storage'), File.dirname(project_b.disk_path))
+
+        FileUtils.mkdir_p(b_storage_dir)
+
+        # Even when overriding the storage, we have to move it there, so it exists
+        FileUtils.mv(
+          File.join(Settings.absolute(storages['default'].legacy_disk_path), project_b.repository.disk_path + '.git'),
+          Rails.root.join(storages['test_second_storage'].legacy_disk_path, project_b.repository.disk_path + '.git')
+        )
+
         expect { run_rake_task('gitlab:backup:create') }.to output.to_stdout
 
         tar_contents, exit_status = Gitlab::Popen.popen(