namespace.rb 8.54 KB
Newer Older
1
class Namespace < ActiveRecord::Base
2 3
  acts_as_paranoid

4
  prepend EE::Namespace
5
  include CacheMarkdownField
6
  include Sortable
7
  include Gitlab::ShellAdapter
8
  include Gitlab::CurrentSettings
9
  include Routable
10

11 12 13 14 15
  # Prevent users from creating unreasonably deep level of nesting.
  # The number 20 was taken based on maximum nesting level of
  # Android repo (15) + some extra backup.
  NUMBER_OF_ANCESTORS_ALLOWED = 20

16 17
  cache_markdown_field :description, pipeline: :description

18
  has_many :projects, dependent: :destroy
19
  has_many :project_statistics
20 21
  belongs_to :owner, class_name: "User"

22 23
  belongs_to :parent, class_name: "Namespace"
  has_many :children, class_name: "Namespace", foreign_key: :parent_id
24
  has_one :chat_team, dependent: :destroy
25

26
  validates :owner, presence: true, unless: ->(n) { n.type == "Group" }
27
  validates :name,
28
    presence: true,
29
    uniqueness: { scope: :parent_id },
30 31
    length: { maximum: 255 },
    namespace_name: true
32

33
  validates :description, length: { maximum: 255 }
34
  validates :path,
35
    presence: true,
36
    length: { maximum: 255 },
37
    dynamic_path: true
38

39 40
  validate :nesting_level_allowed

41 42
  delegate :name, to: :owner, allow_nil: true, prefix: true

43
  after_update :move_dir, if: :path_changed?
44
  after_commit :refresh_access_of_projects_invited_groups, on: :update, if: -> { previous_changes.key?('share_with_group_lock') }
45 46

  # Save the storage paths before the projects are destroyed to use them on after destroy
47
  before_destroy(prepend: true) { prepare_for_destroy }
48
  after_destroy :rm_dir
49

50
  scope :root, -> { where('type IS NULL') }
51

52 53 54 55 56 57 58 59 60 61 62 63
  scope :with_statistics, -> do
    joins('LEFT JOIN project_statistics ps ON ps.namespace_id = namespaces.id')
      .group('namespaces.id')
      .select(
        'namespaces.*',
        'COALESCE(SUM(ps.storage_size), 0) AS storage_size',
        'COALESCE(SUM(ps.repository_size), 0) AS repository_size',
        'COALESCE(SUM(ps.lfs_objects_size), 0) AS lfs_objects_size',
        'COALESCE(SUM(ps.build_artifacts_size), 0) AS build_artifacts_size',
      )
  end

64 65
  class << self
    def by_path(path)
Gabriel Mazetto's avatar
Gabriel Mazetto committed
66
      find_by('lower(path) = :value', value: path.downcase)
67 68 69 70 71 72 73
    end

    # Case insensetive search for namespace by path or name
    def find_by_path_or_name(path)
      find_by("lower(path) = :path OR lower(name) = :path", path: path.downcase)
    end

74 75 76 77 78 79 80
    # Searches for namespaces matching the given query.
    #
    # This method uses ILIKE on PostgreSQL and LIKE on MySQL.
    #
    # query - The search query as a String
    #
    # Returns an ActiveRecord::Relation
81
    def search(query)
82 83 84 85
      t = arel_table
      pattern = "%#{query}%"

      where(t[:name].matches(pattern).or(t[:path].matches(pattern)))
86 87 88
    end

    def clean_path(path)
89
      path = path.dup
90
      # Get the email username by removing everything after an `@` sign.
91
      path.gsub!(/@.*\z/,                "")
92
      # Remove everything that's not in the list of allowed characters.
93 94 95 96 97
      path.gsub!(/[^a-zA-Z0-9_\-\.]/,    "")
      # Remove trailing violations ('.atom', '.git', or '.')
      path.gsub!(/(\.atom|\.git|\.)*\z/, "")
      # Remove leading violations ('-')
      path.gsub!(/\A\-+/,                "")
98

99
      # Users with the great usernames of "." or ".." would end up with a blank username.
100
      # Work around that by setting their username to "blank", followed by a counter.
101 102
      path = "blank" if path.blank?

103
      uniquify = Uniquify.new
104
      uniquify.string(path) { |s| Namespace.find_by_path_or_name(s) }
105
    end
106 107
  end

108
  def to_param
109
    full_path
110
  end
111 112 113 114

  def human_name
    owner_name
  end
115

116
  def move_dir
117
    if any_project_has_container_registry_tags?
118
      raise Gitlab::UpdatePathError.new('Namespace cannot be moved, because at least one project has tags in container registry')
119 120
    end

121 122 123
    # Move the namespace directory in all storages paths used by member projects
    repository_storage_paths.each do |repository_storage_path|
      # Ensure old directory exists before moving it
124
      gitlab_shell.add_namespace(repository_storage_path, full_path_was)
125

126 127
      unless gitlab_shell.mv_namespace(repository_storage_path, full_path_was, full_path)
        Rails.logger.error "Exception moving path #{repository_storage_path} from #{full_path_was} to #{full_path}"
Chris's avatar
Chris committed
128

129 130
        # if we cannot move namespace directory we should rollback
        # db changes in order to prevent out of sync between db and fs
131
        raise Gitlab::UpdatePathError.new('namespace directory cannot be moved')
132
      end
133 134
    end

135 136
    Gitlab::UploadsTransfer.new.rename_namespace(full_path_was, full_path)
    Gitlab::PagesTransfer.new.rename_namespace(full_path_was, full_path)
137

138 139
    remove_exports!

140 141 142 143 144 145 146 147 148 149
    # If repositories moved successfully we need to
    # send update instructions to users.
    # However we cannot allow rollback since we moved namespace dir
    # So we basically we mute exceptions in next actions
    begin
      send_update_instructions
    rescue
      # Returning false does not rollback after_* transaction but gives
      # us information about failing some of tasks
      false
150
    end
151
  end
152

153
  def any_project_has_container_registry_tags?
154
    all_projects.any?(&:has_container_registry_tags?)
155 156
  end

157
  def send_update_instructions
158
    projects.each do |project|
159
      project.send_move_instructions("#{full_path_was}/#{project.path}")
160
    end
161
  end
162 163 164 165

  def kind
    type == 'Group' ? 'group' : 'user'
  end
166 167

  def find_fork_of(project)
Gabriel Mazetto's avatar
Gabriel Mazetto committed
168
    projects.joins(:forked_project_link).find_by('forked_project_links.forked_from_project_id = ?', project.id)
169
  end
170

171 172 173 174 175
  def lfs_enabled?
    # User namespace will always default to the global setting
    Gitlab.config.lfs.enabled
  end

176
  def actual_size_limit
177
    current_application_settings.repository_size_limit
178 179
  end

180 181 182 183
  def shared_runners_enabled?
    projects.with_shared_runners.any?
  end

184 185 186
  # Scopes the model on ancestors of the record
  def ancestors
    if parent_id
187
      path = route ? route.path : full_path
188 189 190 191 192 193 194
      paths = []

      until path.blank?
        path = path.rpartition('/').first
        paths << path
      end

195
      self.class.joins(:route).where('routes.path IN (?)', paths).reorder('routes.path ASC')
196 197 198 199 200 201 202
    else
      self.class.none
    end
  end

  # Scopes the model on direct and indirect children of the record
  def descendants
203
    self.class.joins(:route).merge(Route.inside_path(route.path)).reorder('routes.path ASC')
204 205
  end

206 207 208 209
  def user_ids_for_project_authorizations
    [owner_id]
  end

210 211 212 213
  def parent_changed?
    parent_id_changed?
  end

214 215 216 217 218 219 220 221
  def prepare_for_destroy
    old_repository_storage_paths
  end

  def old_repository_storage_paths
    @old_repository_storage_paths ||= repository_storage_paths
  end

222 223 224 225 226 227
  # Includes projects from this namespace and projects from all subgroups
  # that belongs to this namespace
  def all_projects
    Project.inside_path(full_path)
  end

228 229 230 231
  def has_parent?
    parent.present?
  end

232 233 234 235 236 237 238
  private

  def repository_storage_paths
    # 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
239
      all_projects.select('distinct(repository_storage)').to_a.map(&:repository_storage_path)
240 241 242 243 244
    end
  end

  def rm_dir
    # Remove the namespace directory in all storages paths used by member projects
245
    old_repository_storage_paths.each do |repository_storage_path|
246 247
      # Move namespace directory into trash.
      # We will remove it later async
248
      new_path = "#{full_path}+#{id}+deleted"
249

250 251
      if gitlab_shell.mv_namespace(repository_storage_path, full_path, new_path)
        message = "Namespace directory \"#{full_path}\" moved to \"#{new_path}\""
252 253 254 255 256 257 258
        Gitlab::AppLogger.info message

        # Remove namespace directroy async with delay so
        # GitLab has time to remove all projects first
        GitlabShellWorker.perform_in(5.minutes, :rm_namespace, repository_storage_path, new_path)
      end
    end
259 260

    remove_exports!
261
  end
262 263 264 265 266 267 268

  def refresh_access_of_projects_invited_groups
    Group.
      joins(project_group_links: :project).
      where(projects: { namespace_id: id }).
      find_each(&:refresh_members_authorized_projects)
  end
269

270 271 272 273 274 275 276 277 278 279 280 281 282 283 284
  def remove_exports!
    Gitlab::Popen.popen(%W(find #{export_path} -not -path #{export_path} -delete))
  end

  def export_path
    File.join(Gitlab::ImportExport.storage_path, full_path_was)
  end

  def full_path_was
    if parent
      parent.full_path + '/' + path_was
    else
      path_was
    end
  end
285 286 287 288 289 290

  def nesting_level_allowed
    if ancestors.count > Group::NUMBER_OF_ANCESTORS_ALLOWED
      errors.add(:parent_id, "has too deep level of nesting")
    end
  end
291
end