BigW Consortium Gitlab

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

4
  include CacheMarkdownField
5
  include Sortable
6
  include Gitlab::ShellAdapter
7
  include Gitlab::CurrentSettings
8
  include Gitlab::VisibilityLevel
9
  include Routable
10
  include AfterCommitQueue
11
  include Storage::LegacyNamespace
12

13 14 15 16 17
  # 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

18 19
  cache_markdown_field :description, pipeline: :description

20
  has_many :projects, dependent: :destroy # rubocop:disable Cop/ActiveRecordDependent
21
  has_many :project_statistics
22 23
  belongs_to :owner, class_name: "User"

24 25
  belongs_to :parent, class_name: "Namespace"
  has_many :children, class_name: "Namespace", foreign_key: :parent_id
26
  has_one :chat_team, dependent: :destroy # rubocop:disable Cop/ActiveRecordDependent
27

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

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

41 42
  validate :nesting_level_allowed

43 44
  delegate :name, to: :owner, allow_nil: true, prefix: true

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

47 48
  before_create :sync_share_with_group_lock_with_parent
  before_update :sync_share_with_group_lock_with_parent, if: :parent_changed?
49
  after_update :force_share_with_group_lock_on_descendants, if: -> { share_with_group_lock_changed? && share_with_group_lock? }
50

51 52 53
  # Legacy Storage specific hooks

  after_update :move_dir, if: :path_changed?
54
  before_destroy(prepend: true) { prepare_for_destroy }
55
  after_destroy :rm_dir
56

57
  scope :for_user, -> { where('type IS NULL') }
58

59 60 61 62 63 64 65 66
  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',
67
        'COALESCE(SUM(ps.build_artifacts_size), 0) AS build_artifacts_size'
68 69 70
      )
  end

71 72
  class << self
    def by_path(path)
73
      find_by('lower(path) = :value', value: path.downcase)
74 75 76 77 78 79 80
    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

81 82 83 84 85 86 87
    # 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
88
    def search(query)
89 90 91 92
      t = arel_table
      pattern = "%#{query}%"

      where(t[:name].matches(pattern).or(t[:path].matches(pattern)))
93 94 95
    end

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

106
      # Users with the great usernames of "." or ".." would end up with a blank username.
107
      # Work around that by setting their username to "blank", followed by a counter.
108 109
      path = "blank" if path.blank?

110
      uniquify = Uniquify.new
111
      uniquify.string(path) { |s| Namespace.find_by_path_or_name(s) }
112
    end
113 114
  end

115 116 117 118
  def visibility_level_field
    :visibility_level
  end

119
  def to_param
120
    full_path
121
  end
122 123 124 125

  def human_name
    owner_name
  end
126

127
  def any_project_has_container_registry_tags?
128
    all_projects.any?(&:has_container_registry_tags?)
129 130
  end

131 132 133 134 135 136
  def send_update_instructions
    projects.each do |project|
      project.send_move_instructions("#{full_path_was}/#{project.path}")
    end
  end

137 138 139
  def kind
    type == 'Group' ? 'group' : 'user'
  end
140 141

  def find_fork_of(project)
142
    projects.joins(:forked_project_link).find_by('forked_project_links.forked_from_project_id = ?', project.id)
143
  end
144

145 146 147 148 149
  def lfs_enabled?
    # User namespace will always default to the global setting
    Gitlab.config.lfs.enabled
  end

150 151 152 153
  def shared_runners_enabled?
    projects.with_shared_runners.any?
  end

154
  # Returns all the ancestors of the current namespaces.
155
  def ancestors
156
    return self.class.none unless parent_id
157

158 159 160
    Gitlab::GroupHierarchy
      .new(self.class.where(id: parent_id))
      .base_and_ancestors
161 162
  end

163 164 165 166 167 168 169 170
  def self_and_ancestors
    return self.class.where(id: id) unless parent_id

    Gitlab::GroupHierarchy
      .new(self.class.where(id: id))
      .base_and_ancestors
  end

171
  # Returns all the descendants of the current namespace.
172
  def descendants
173 174 175
    Gitlab::GroupHierarchy
      .new(self.class.where(parent_id: id))
      .base_and_descendants
176 177
  end

178 179 180 181 182 183
  def self_and_descendants
    Gitlab::GroupHierarchy
      .new(self.class.where(id: id))
      .base_and_descendants
  end

184 185 186 187
  def user_ids_for_project_authorizations
    [owner_id]
  end

188 189 190 191
  def parent_changed?
    parent_id_changed?
  end

192 193 194 195 196 197
  # Includes projects from this namespace and projects from all subgroups
  # that belongs to this namespace
  def all_projects
    Project.inside_path(full_path)
  end

198 199 200 201
  def has_parent?
    parent.present?
  end

202 203 204 205
  def subgroup?
    has_parent?
  end

206 207 208 209 210 211
  def soft_delete_without_removing_associations
    # We can't use paranoia's `#destroy` since this will hard-delete projects.
    # Project uses `pending_delete` instead of the acts_as_paranoia gem.
    self.deleted_at = Time.now
  end

212 213
  private

214
  def refresh_access_of_projects_invited_groups
215 216 217 218
    Group
      .joins(project_group_links: :project)
      .where(projects: { namespace_id: id })
      .find_each(&:refresh_members_authorized_projects)
219
  end
220

221 222 223 224 225
  def nesting_level_allowed
    if ancestors.count > Group::NUMBER_OF_ANCESTORS_ALLOWED
      errors.add(:parent_id, "has too deep level of nesting")
    end
  end
226 227

  def sync_share_with_group_lock_with_parent
228
    if parent&.share_with_group_lock?
229 230 231 232 233
      self.share_with_group_lock = true
    end
  end

  def force_share_with_group_lock_on_descendants
234 235 236 237 238 239 240 241
    return unless Group.supports_nested_groups?

    # We can't use `descendants.update_all` since Rails will throw away the WITH
    # RECURSIVE statement. We also can't use WHERE EXISTS since we can't use
    # different table aliases, hence we're just using WHERE IN. Since we have a
    # maximum of 20 nested groups this should be fine.
    Namespace.where(id: descendants.select(:id))
      .update_all(share_with_group_lock: true)
242
  end
243
end