project.rb 61.5 KB
Newer Older
1 2
require 'carrierwave/orm/activerecord'

gitlabhq's avatar
gitlabhq committed
3
class Project < ActiveRecord::Base
4
  include Gitlab::ConfigHelper
5
  include Gitlab::ShellAdapter
6
  include Gitlab::VisibilityLevel
7
  include AccessRequestable
8
  include Avatarable
9
  include CacheMarkdownField
10 11
  include Referable
  include Sortable
12
  include AfterCommitQueue
13
  include CaseSensitivity
14
  include TokenAuthenticatable
15
  include ValidAttribute
16
  include ProjectFeaturesCompatibility
17
  include SelectForProjectAuthorization
18
  include Presentable
19
  include Routable
20
  include GroupDescendant
21
  include Gitlab::SQL::Pattern
22
  include DeploymentPlatform
23
  include ::Gitlab::Utils::StrongMemoize
24
  include ChronicDurationAttribute
Robert Speicher's avatar
Robert Speicher committed
25

26
  extend Gitlab::ConfigHelper
27

28
  BoardLimitExceeded = Class.new(StandardError)
29

30
  NUMBER_OF_PERMITTED_BOARDS = 1
Douwe Maan's avatar
Douwe Maan committed
31
  UNKNOWN_IMPORT_URL = 'http://unknown.git'.freeze
32 33
  # Hashed Storage versions handle rolling out new storage to project and dependents models:
  # nil: legacy
34 35 36
  # 1: repository
  # 2: attachments
  LATEST_STORAGE_VERSION = 2
37 38 39 40
  HASHED_STORAGE_FEATURES = {
    repository: 1,
    attachments: 2
  }.freeze
Jared Szechy's avatar
Jared Szechy committed
41

42 43 44
  # Valids ports to import from
  VALID_IMPORT_PORTS = [22, 80, 443].freeze

45 46
  cache_markdown_field :description, pipeline: :description

47 48
  delegate :feature_available?, :builds_enabled?, :wiki_enabled?,
           :merge_requests_enabled?, :issues_enabled?, to: :project_feature,
49
                                                       allow_nil: true
50

51
  delegate :base_dir, :disk_path, :ensure_storage_path_exists, to: :storage
52

53
  default_value_for :archived, false
54
  default_value_for :visibility_level, gitlab_config_features.visibility_level
55
  default_value_for :resolve_outdated_diff_discussions, false
56
  default_value_for :container_registry_enabled, gitlab_config_features.container_registry
57 58
  default_value_for(:repository_storage) { Gitlab::CurrentSettings.pick_repository_storage }
  default_value_for(:shared_runners_enabled) { Gitlab::CurrentSettings.shared_runners_enabled }
59 60 61 62 63
  default_value_for :issues_enabled, gitlab_config_features.issues
  default_value_for :merge_requests_enabled, gitlab_config_features.merge_requests
  default_value_for :builds_enabled, gitlab_config_features.builds
  default_value_for :wiki_enabled, gitlab_config_features.wiki
  default_value_for :snippets_enabled, gitlab_config_features.snippets
64
  default_value_for :only_allow_merge_if_all_discussions_are_resolved, false
65

66
  add_authentication_token_field :runners_token
67

68
  before_validation :mark_remote_mirrors_for_removal, if: -> { ActiveRecord::Base.connection.table_exists?(:remote_mirrors) }
69

70
  before_save :ensure_runners_token
71

72
  after_save :update_project_statistics, if: :namespace_id_changed?
73 74 75

  after_save :create_import_state, if: ->(project) { project.import? && project.import_state.nil? }

76
  after_create :create_project_feature, unless: :project_feature
77 78 79 80 81

  after_create :create_ci_cd_settings,
    unless: :ci_cd_settings,
    if: proc { ProjectCiCdSetting.available? }

82
  after_create :set_last_activity_at
83
  after_create :set_last_repository_updated_at
84
  after_update :update_forks_visibility_level
85

86
  before_destroy :remove_private_deploy_keys
87
  after_destroy -> { run_after_commit { remove_pages } }
88
  after_destroy :remove_exports
Kamil Trzcinski's avatar
Kamil Trzcinski committed
89

90 91
  after_validation :check_pending_delete

92
  # Storage specific hooks
93
  after_initialize :use_hashed_storage
94
  after_create :check_repository_absence!
95 96
  after_create :ensure_storage_path_exists
  after_save :ensure_storage_path_exists, if: :namespace_id_changed?
97

98
  acts_as_taggable
99

100
  attr_accessor :old_path_with_namespace
101
  attr_accessor :template_name
102
  attr_writer :pipeline_status
103
  attr_accessor :skip_disk_validation
104

105 106
  alias_attribute :title, :name

107
  # Relations
108
  belongs_to :creator, class_name: 'User'
109
  belongs_to :group, -> { where(type: 'Group') }, foreign_key: 'namespace_id'
110
  belongs_to :namespace
111 112
  alias_method :parent, :namespace
  alias_attribute :parent_id, :namespace_id
113

114
  has_one :last_event, -> {order 'events.created_at DESC'}, class_name: 'Event'
115
  has_many :boards, before_add: :validate_board_limit
116

117
  # Project services
118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148
  has_one :campfire_service
  has_one :drone_ci_service
  has_one :emails_on_push_service
  has_one :pipelines_email_service
  has_one :irker_service
  has_one :pivotaltracker_service
  has_one :hipchat_service
  has_one :flowdock_service
  has_one :assembla_service
  has_one :asana_service
  has_one :gemnasium_service
  has_one :mattermost_slash_commands_service
  has_one :mattermost_service
  has_one :slack_slash_commands_service
  has_one :slack_service
  has_one :buildkite_service
  has_one :bamboo_service
  has_one :teamcity_service
  has_one :pushover_service
  has_one :jira_service
  has_one :redmine_service
  has_one :custom_issue_tracker_service
  has_one :bugzilla_service
  has_one :gitlab_issue_tracker_service, inverse_of: :project
  has_one :external_wiki_service
  has_one :kubernetes_service, inverse_of: :project
  has_one :prometheus_service, inverse_of: :project
  has_one :mock_ci_service
  has_one :mock_deployment_service
  has_one :mock_monitoring_service
  has_one :microsoft_teams_service
149
  has_one :packagist_service
150

151
  # TODO: replace these relations with the fork network versions
152 153
  has_one  :forked_project_link,  foreign_key: "forked_to_project_id"
  has_one  :forked_from_project,  through:   :forked_project_link
154 155

  has_many :forked_project_links, foreign_key: "forked_from_project_id"
156
  has_many :forks,                through:     :forked_project_links, source: :forked_to_project
157 158 159 160 161 162 163
  # TODO: replace these relations with the fork network versions

  has_one :root_of_fork_network,
          foreign_key: 'root_project_id',
          inverse_of: :root_project,
          class_name: 'ForkNetwork'
  has_one :fork_network_member
164
  has_one :fork_network, through: :fork_network_member
165

166 167
  has_one :import_state, autosave: true, class_name: 'ProjectImportState', inverse_of: :project

168
  # Merge Requests for target project should be removed with it
169
  has_many :merge_requests, foreign_key: 'target_project_id'
170
  has_many :source_of_merge_requests, foreign_key: 'source_project_id', class_name: 'MergeRequest'
171 172 173 174 175 176 177 178 179 180
  has_many :issues
  has_many :labels, class_name: 'ProjectLabel'
  has_many :services
  has_many :events
  has_many :milestones
  has_many :notes
  has_many :snippets, class_name: 'ProjectSnippet'
  has_many :hooks, class_name: 'ProjectHook'
  has_many :protected_branches
  has_many :protected_tags
181

182
  has_many :project_authorizations
183
  has_many :authorized_users, through: :project_authorizations, source: :user, class_name: 'User'
184
  has_many :project_members, -> { where(requested_at: nil) },
185
    as: :source, dependent: :delete_all # rubocop:disable Cop/ActiveRecordDependent
186

187
  alias_method :members, :project_members
188
  has_many :users, through: :project_members
189

190
  has_many :requesters, -> { where.not(requested_at: nil) },
191
    as: :source, class_name: 'ProjectMember', dependent: :delete_all # rubocop:disable Cop/ActiveRecordDependent
192
  has_many :members_and_requesters, as: :source, class_name: 'ProjectMember'
193

194
  has_many :deploy_keys_projects
195
  has_many :deploy_keys, through: :deploy_keys_projects
196
  has_many :users_star_projects
197
  has_many :starrers, through: :users_star_projects, source: :user
198
  has_many :releases
199
  has_many :lfs_objects_projects, dependent: :destroy # rubocop:disable Cop/ActiveRecordDependent
200
  has_many :lfs_objects, through: :lfs_objects_projects
201
  has_many :lfs_file_locks
202
  has_many :project_group_links
203
  has_many :invited_groups, through: :project_group_links, source: :group
204 205
  has_many :pages_domains
  has_many :todos
206
  has_many :notification_settings, as: :source, dependent: :delete_all # rubocop:disable Cop/ActiveRecordDependent
207

208 209
  has_many :internal_ids

210
  has_one :import_data, class_name: 'ProjectImportData', inverse_of: :project, autosave: true
211
  has_one :project_feature, inverse_of: :project
212
  has_one :statistics, class_name: 'ProjectStatistics'
213

Shinya Maeda's avatar
Shinya Maeda committed
214
  has_one :cluster_project, class_name: 'Clusters::Project'
215
  has_many :clusters, through: :cluster_project, class_name: 'Clusters::Cluster'
216

217 218 219
  # Container repositories need to remove data from the container registry,
  # which is not managed by the DB. Hence we're still using dependent: :destroy
  # here.
220
  has_many :container_repositories, dependent: :destroy # rubocop:disable Cop/ActiveRecordDependent
221

222
  has_many :commit_statuses
223
  has_many :pipelines, class_name: 'Ci::Pipeline', inverse_of: :project
224 225 226 227 228

  # Ci::Build objects store data on the file system such as artifact files and
  # build traces. Currently there's no efficient way of removing this data in
  # bulk that doesn't involve loading the rows into memory. As a result we're
  # still using `dependent: :destroy` here.
229
  has_many :builds, class_name: 'Ci::Build', inverse_of: :project, dependent: :destroy # rubocop:disable Cop/ActiveRecordDependent
230
  has_many :build_trace_section_names, class_name: 'Ci::BuildTraceSectionName'
231
  has_many :runner_projects, class_name: 'Ci::RunnerProject'
232
  has_many :runners, through: :runner_projects, source: :runner, class_name: 'Ci::Runner'
233
  has_many :variables, class_name: 'Ci::Variable'
234 235 236 237
  has_many :triggers, class_name: 'Ci::Trigger'
  has_many :environments
  has_many :deployments
  has_many :pipeline_schedules, class_name: 'Ci::PipelineSchedule'
238
  has_many :project_deploy_tokens
239
  has_many :deploy_tokens, through: :project_deploy_tokens
240

241
  has_one :auto_devops, class_name: 'ProjectAutoDevops'
242
  has_many :custom_attributes, class_name: 'ProjectCustomAttribute'
243

244
  has_many :project_badges, class_name: 'ProjectBadge'
245
  has_one :ci_cd_settings, class_name: 'ProjectCiCdSetting', inverse_of: :project, autosave: true, dependent: :destroy # rubocop:disable Cop/ActiveRecordDependent
246

247 248
  has_many :remote_mirrors, inverse_of: :project

249
  accepts_nested_attributes_for :variables, allow_destroy: true
250
  accepts_nested_attributes_for :project_feature, update_only: true
251
  accepts_nested_attributes_for :import_data
252
  accepts_nested_attributes_for :auto_devops, update_only: true
253

254 255 256 257
  accepts_nested_attributes_for :remote_mirrors,
                                allow_destroy: true,
                                reject_if: ->(attrs) { attrs[:id].blank? && attrs[:url].blank? }

258
  delegate :name, to: :owner, allow_nil: true, prefix: true
259
  delegate :members, to: :team, prefix: true
260
  delegate :add_user, :add_users, to: :team
261
  delegate :add_guest, :add_reporter, :add_developer, :add_master, :add_role, to: :team
262
  delegate :group_runners_enabled, :group_runners_enabled=, :group_runners_enabled?, to: :ci_cd_settings
263

Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
264
  # Validations
265
  validates :creator, presence: true, on: :create
266
  validates :description, length: { maximum: 2000 }, allow_blank: true
267
  validates :ci_config_path,
268
    format: { without: %r{(\.{2}|\A/)},
269
              message: 'cannot include leading slash or directory traversal.' },
270 271
    length: { maximum: 255 },
    allow_blank: true
272 273
  validates :name,
    presence: true,
274
    length: { maximum: 255 },
275
    format: { with: Gitlab::Regex.project_name_regex,
Douwe Maan's avatar
Douwe Maan committed
276
              message: Gitlab::Regex.project_name_regex_message }
277 278
  validates :path,
    presence: true,
279
    project_path: true,
280
    length: { maximum: 255 }
281

282
  validates :namespace, presence: true
Douwe Maan's avatar
Douwe Maan committed
283
  validates :name, uniqueness: { scope: :namespace_id }
284
  validates :import_url, addressable_url: true, if: :external_import?
285
  validates :import_url, importable_url: true, if: [:external_import?, :import_url_changed?]
286
  validates :star_count, numericality: { greater_than_or_equal_to: 0 }
287
  validate :check_limit, on: :create
288
  validate :check_repository_path_availability, on: :update, if: ->(project) { project.renamed? }
289
  validate :visibility_level_allowed_by_group
Douwe Maan's avatar
Douwe Maan committed
290
  validate :visibility_level_allowed_as_fork
291
  validate :check_wiki_path_conflict
Rob Watson's avatar
Rob Watson committed
292
  validate :validate_pages_https_only, if: -> { changes.has_key?(:pages_https_only) }
293 294 295
  validates :repository_storage,
    presence: true,
    inclusion: { in: ->(_object) { Gitlab.config.repositories.storages.keys } }
296
  validates :variables, variable_duplicates: { scope: :environment_scope }
297

298
  has_many :uploads, as: :model, dependent: :destroy # rubocop:disable Cop/ActiveRecordDependent
Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
299

300
  # Scopes
301
  scope :pending_delete, -> { where(pending_delete: true) }
302
  scope :without_deleted, -> { where(pending_delete: false) }
303

304 305 306
  scope :with_storage_feature, ->(feature) { where('storage_version >= :version', version: HASHED_STORAGE_FEATURES[feature]) }
  scope :without_storage_feature, ->(feature) { where('storage_version < :version OR storage_version IS NULL', version: HASHED_STORAGE_FEATURES[feature]) }
  scope :with_unmigrated_storage, -> { where('storage_version < :version OR storage_version IS NULL', version: LATEST_STORAGE_VERSION) }
307

308 309
  # last_activity_at is throttled every minute, but last_repository_updated_at is updated with every push
  scope :sorted_by_activity, -> { reorder("GREATEST(COALESCE(last_activity_at, '1970-01-01'), COALESCE(last_repository_updated_at, '1970-01-01')) DESC") }
310 311
  scope :sorted_by_stars, -> { reorder('projects.star_count DESC') }

312
  scope :in_namespace, ->(namespace_ids) { where(namespace_id: namespace_ids) }
313
  scope :personal, ->(user) { where(namespace_id: user.namespace_id) }
314
  scope :joined, ->(user) { where('namespace_id != ?', user.namespace_id) }
315
  scope :starred_by, ->(user) { joins(:users_star_projects).where('users_star_projects.user_id': user.id) }
316
  scope :visible_to_user, ->(user) { where(id: user.authorized_projects.select(:id).reorder(nil)) }
317
  scope :archived, -> { where(archived: true) }
318
  scope :non_archived, -> { where(archived: false) }
319
  scope :for_milestones, ->(ids) { joins(:milestones).where('milestones.id' => ids).distinct }
320
  scope :with_push, -> { joins(:events).where('events.action = ?', Event::PUSHED) }
321
  scope :with_project_feature, -> { joins('LEFT JOIN project_features ON projects.id = project_features.project_id') }
322
  scope :with_statistics, -> { includes(:statistics) }
323
  scope :with_shared_runners, -> { where(shared_runners_enabled: true) }
324 325 326
  scope :inside_path, ->(path) do
    # We need routes alias rs for JOIN so it does not conflict with
    # includes(:route) which we use in ProjectsFinder.
327 328
    joins("INNER JOIN routes rs ON rs.source_id = projects.id AND rs.source_type = 'Project'")
      .where('rs.path LIKE ?', "#{sanitize_sql_like(path)}/%")
329
  end
330 331 332 333 334 335 336 337 338 339 340 341 342 343 344

  # "enabled" here means "not disabled". It includes private features!
  scope :with_feature_enabled, ->(feature) {
    access_level_attribute = ProjectFeature.access_level_attribute(feature)
    with_project_feature.where(project_features: { access_level_attribute => [nil, ProjectFeature::PRIVATE, ProjectFeature::ENABLED] })
  }

  # Picks a feature where the level is exactly that given.
  scope :with_feature_access_level, ->(feature, level) {
    access_level_attribute = ProjectFeature.access_level_attribute(feature)
    with_project_feature.where(project_features: { access_level_attribute => level })
  }

  scope :with_builds_enabled, -> { with_feature_enabled(:builds) }
  scope :with_issues_enabled, -> { with_feature_enabled(:issues) }
345
  scope :with_issues_available_for_user, ->(current_user) { with_feature_available_for_user(:issues, current_user) }
346
  scope :with_merge_requests_enabled, -> { with_feature_enabled(:merge_requests) }
347
  scope :with_remote_mirrors, -> { joins(:remote_mirrors).where(remote_mirrors: { enabled: true }).distinct }
348

349 350 351 352 353
  scope :with_group_runners_enabled, -> do
    joins(:ci_cd_settings)
    .where(project_ci_cd_settings: { group_runners_enabled: true })
  end

354
  enum auto_cancel_pending_pipelines: { disabled: 0, enabled: 1 }
355

356
  chronic_duration_attr :build_timeout_human_readable, :build_timeout, default: 3600
357 358 359 360 361

  validates :build_timeout, allow_nil: true,
                            numericality: { greater_than_or_equal_to: 600,
                                            message: 'needs to be at least 10 minutes' }

362 363
  # Returns a collection of projects that is either public or visible to the
  # logged in user.
364 365
  def self.public_or_visible_to_user(user = nil)
    if user
366 367 368
      where('EXISTS (?) OR projects.visibility_level IN (?)',
            user.authorizations_for_projects,
            Gitlab::VisibilityLevel.levels_for_user(user))
369
    else
370
      public_to_user
371 372 373
    end
  end

374 375 376
  # project features may be "disabled", "internal" or "enabled". If "internal",
  # they are only available to team members. This scope returns projects where
  # the feature is either enabled, or internal with permission for the user.
377 378 379 380
  #
  # This method uses an optimised version of `with_feature_access_level` for
  # logged in users to more efficiently get private projects with the given
  # feature.
381
  def self.with_feature_available_for_user(feature, user)
382 383 384 385 386 387 388
    visible = [nil, ProjectFeature::ENABLED]

    if user&.admin?
      with_feature_enabled(feature)
    elsif user
      column = ProjectFeature.quoted_access_level_column(feature)

389 390
      with_project_feature
        .where("#{column} IN (?) OR (#{column} = ? AND EXISTS (?))",
391 392
              visible,
              ProjectFeature::PRIVATE,
393
              user.authorizations_for_projects)
394 395 396
    else
      with_feature_access_level(feature, visible)
    end
397
  end
398

399 400
  scope :active, -> { joins(:issues, :notes, :merge_requests).order('issues.created_at, notes.created_at, merge_requests.created_at DESC') }
  scope :abandoned, -> { where('projects.last_activity_at < ?', 6.months.ago) }
401

402
  scope :excluding_project, ->(project) { where.not(id: project) }
403

404 405
  scope :joins_import_state, -> { joins("LEFT JOIN project_mirror_data import_state ON import_state.project_id = projects.id") }
  scope :import_started, -> { joins_import_state.where("import_state.status = 'started' OR projects.import_status = 'started'") }
406

Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
407
  class << self
408 409 410 411 412 413 414
    # Searches for a list of projects based on the query given in `query`.
    #
    # On PostgreSQL this method uses "ILIKE" to perform a case-insensitive
    # search. On MySQL a regular "LIKE" is used as it's already
    # case-insensitive.
    #
    # query - The search query as a String.
415
    def search(query)
416
      fuzzy_search(query, [:path, :name, :description])
Andrey Kumanyaev's avatar
Andrey Kumanyaev committed
417
    end
418

419
    def search_by_title(query)
420
      non_archived.fuzzy_search(query, [:name])
421 422
    end

423 424 425
    def visibility_levels
      Gitlab::VisibilityLevel.options
    end
426

427
    def sort_by_attribute(method)
428 429
      case method.to_s
      when 'storage_size_desc'
430 431 432
        # storage_size is a joined column so we need to
        # pass a string to avoid AR adding the table name
        reorder('project_statistics.storage_size DESC, projects.id DESC')
433 434 435 436
      when 'latest_activity_desc'
        reorder(last_activity_at: :desc)
      when 'latest_activity_asc'
        reorder(last_activity_at: :asc)
437 438
      else
        order_by(method)
439 440
      end
    end
441 442

    def reference_pattern
443
      %r{
444 445
        ((?<namespace>#{Gitlab::PathRegex::FULL_NAMESPACE_FORMAT_REGEX})\/)?
        (?<project>#{Gitlab::PathRegex::PROJECT_PATH_FORMAT_REGEX})
446
      }x
447
    end
448

449
    def trending
450 451
      joins('INNER JOIN trending_projects ON projects.id = trending_projects.project_id')
        .reorder('trending_projects.id ASC')
452
    end
453 454 455 456 457 458

    def cached_count
      Rails.cache.fetch('total_project_count', expires_in: 5.minutes) do
        Project.count
      end
    end
459 460

    def group_ids
461
      joins(:namespace).where(namespaces: { type: 'Group' }).select(:namespace_id)
462
    end
463 464
  end

465 466 467 468 469 470 471
  # returns all ancestor-groups upto but excluding the given namespace
  # when no namespace is given, all ancestors upto the top are returned
  def ancestors_upto(top = nil)
    Gitlab::GroupHierarchy.new(Group.where(id: namespace_id))
      .base_and_ancestors(upto: top)
  end

472
  def lfs_enabled?
473
    return namespace.lfs_enabled? if self[:lfs_enabled].nil?
Patricio Cano's avatar
Patricio Cano committed
474

475
    self[:lfs_enabled] && Gitlab.config.lfs.enabled
476 477
  end

478
  def auto_devops_enabled?
479
    if auto_devops&.enabled.nil?
480
      Gitlab::CurrentSettings.auto_devops_enabled?
481 482
    else
      auto_devops.enabled?
Zeger-Jan van de Weg's avatar
Zeger-Jan van de Weg committed
483
    end
484 485
  end

486
  def has_auto_devops_implicitly_disabled?
487
    auto_devops&.enabled.nil? && !Gitlab::CurrentSettings.auto_devops_enabled?
488 489
  end

490 491 492 493
  def empty_repo?
    repository.empty?
  end

Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
494
  def team
495
    @team ||= ProjectTeam.new(self)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
496 497 498
  end

  def repository
499
    @repository ||= Repository.new(full_path, self, disk_path: disk_path)
500 501
  end

502 503
  def cleanup
    @repository&.cleanup
504 505 506
    @repository = nil
  end

507 508
  alias_method :reload_repository!, :cleanup

509
  def container_registry_url
Kamil Trzcinski's avatar
Kamil Trzcinski committed
510
    if Gitlab.config.registry.enabled
511
      "#{Gitlab.config.registry.host_port}/#{full_path.downcase}"
512
    end
513 514
  end

515
  def has_container_registry_tags?
516 517 518
    return @images if defined?(@images)

    @images = container_repositories.to_a.any?(&:has_tags?) ||
519
      has_root_container_repository_tags?
520 521
  end

522 523
  def commit(ref = 'HEAD')
    repository.commit(ref)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
524 525
  end

526 527 528 529
  def commit_by(oid:)
    repository.commit_by(oid: oid)
  end

530
  # ref can't be HEAD, can only be branch/tag name or SHA
531
  def latest_successful_builds_for(ref = default_branch)
532
    latest_pipeline = pipelines.latest_successful_for(ref)
533 534

    if latest_pipeline
535
      latest_pipeline.builds.latest.with_artifacts_archive
536 537 538
    else
      builds.none
    end
539 540
  end

541
  def merge_base_commit(first_commit_id, second_commit_id)
Douwe Maan's avatar
Douwe Maan committed
542
    sha = repository.merge_base(first_commit_id, second_commit_id)
543
    commit_by(oid: sha) if sha
544 545
  end

546
  def saved?
547
    id && persisted?
548 549
  end

550
  def add_import_job
Douwe Maan's avatar
Douwe Maan committed
551 552
    job_id =
      if forked?
553
        RepositoryForkWorker.perform_async(id)
554
      elsif gitlab_project_import?
James Lopez's avatar
James Lopez committed
555
        # Do not retry on Import/Export until https://gitlab.com/gitlab-org/gitlab-ce/issues/26189 is solved.
556
        RepositoryImportWorker.set(retry: false).perform_async(self.id)
Douwe Maan's avatar
Douwe Maan committed
557 558 559
      else
        RepositoryImportWorker.perform_async(self.id)
      end
560

561 562 563 564 565 566 567 568
    log_import_activity(job_id)

    job_id
  end

  def log_import_activity(job_id, type: :import)
    job_type = type.to_s.capitalize

569
    if job_id
570
      Rails.logger.info("#{job_type} job scheduled for #{full_path} with job ID #{job_id}.")
571
    else
572
      Rails.logger.error("#{job_type} job failed to create for #{full_path}.")
573
    end
574 575
  end

576 577 578 579 580
  def reset_cache_and_import_attrs
    run_after_commit do
      ProjectCacheWorker.perform_async(self.id)
    end

581
    update(import_error: nil)
582 583 584 585 586
    remove_import_data
  end

  # This method is overriden in EE::Project model
  def remove_import_data
587
    import_data&.destroy
588 589
  end

590
  def ci_config_path=(value)
591
    # Strip all leading slashes so that //foo -> foo
592
    super(value&.delete("\0"))
593 594
  end

595
  def import_url=(value)
596 597
    return super(value) unless Gitlab::UrlSanitizer.valid?(value)

598
    import_url = Gitlab::UrlSanitizer.new(value)
James Lopez's avatar
James Lopez committed
599
    super(import_url.sanitized_url)
600
    create_or_update_import_data(credentials: import_url.credentials)
601 602 603
  end

  def import_url
James Lopez's avatar
James Lopez committed
604
    if import_data && super.present?
605
      import_url = Gitlab::UrlSanitizer.new(super, credentials: import_data.credentials)
James Lopez's avatar
James Lopez committed
606 607 608
      import_url.full_url
    else
      super
609 610
    end
  end
611

James Lopez's avatar
James Lopez committed
612
  def valid_import_url?
613
    valid?(:import_url) || errors.messages[:import_url].nil?
James Lopez's avatar
James Lopez committed
614 615
  end

616
  def create_or_update_import_data(data: nil, credentials: nil)
617
    return if data.nil? && credentials.nil?
618

James Lopez's avatar
James Lopez committed
619
    project_import_data = import_data || build_import_data
620 621 622 623
    if data
      project_import_data.data ||= {}
      project_import_data.data = project_import_data.data.merge(data)
    end
624

625 626 627 628
    if credentials
      project_import_data.credentials ||= {}
      project_import_data.credentials = project_import_data.credentials.merge(credentials)
    end
629
  end
630

631
  def import?
632
    external_import? || forked? || gitlab_project_import? || bare_repository_import?
633 634 635
  end

  def external_import?
636 637 638
    import_url.present?
  end

639
  def imported?
640 641 642 643
    import_finished?
  end

  def import_in_progress?
644 645 646
    import_started? || import_scheduled?
  end

647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733
  def import_state_args
    {
      status: self[:import_status],
      jid: self[:import_jid],
      last_error: self[:import_error]
    }
  end

  def ensure_import_state
    return if self[:import_status] == 'none' || self[:import_status].nil?
    return unless import_state.nil?

    create_import_state(import_state_args)

    update_column(:import_status, 'none')
  end

  def import_schedule
    ensure_import_state

    import_state&.schedule
  end

  def force_import_start
    ensure_import_state

    import_state&.force_start
  end

  def import_start
    ensure_import_state

    import_state&.start
  end

  def import_fail
    ensure_import_state

    import_state&.fail_op
  end

  def import_finish
    ensure_import_state

    import_state&.finish
  end

  def import_jid=(new_jid)
    ensure_import_state

    import_state&.jid = new_jid
  end

  def import_jid
    ensure_import_state

    import_state&.jid
  end

  def import_error=(new_error)
    ensure_import_state

    import_state&.last_error = new_error
  end

  def import_error
    ensure_import_state

    import_state&.last_error
  end

  def import_status=(new_status)
    ensure_import_state

    import_state&.status = new_status
  end

  def import_status
    ensure_import_state

    import_state&.status || 'none'
  end

  def no_import?
    import_status == 'none'
  end

734
  def import_started?
735 736
    # import? does SQL work so only run it if it looks like there's an import running
    import_status == 'started' && import?
737 738
  end

739 740 741 742
  def import_scheduled?
    import_status == 'scheduled'
  end

743 744 745 746 747 748
  def import_failed?
    import_status == 'failed'
  end

  def import_finished?
    import_status == 'finished'
749 750
  end

751
  def safe_import_url
752
    Gitlab::UrlSanitizer.new(import_url).masked_url
753 754
  end

755 756 757 758
  def bare_repository_import?
    import_type == 'bare_repository'
  end

759 760 761 762
  def gitlab_project_import?
    import_type == 'gitlab_project'
  end

Rémy Coutable's avatar
Rémy Coutable committed
763 764 765 766
  def gitea_import?
    import_type == 'gitea'
  end

767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797
  def has_remote_mirror?
    remote_mirror_available? && remote_mirrors.enabled.exists?
  end

  def updating_remote_mirror?
    remote_mirrors.enabled.started.exists?
  end

  def update_remote_mirrors
    return unless remote_mirror_available?

    remote_mirrors.enabled.each(&:sync)
  end

  def mark_stuck_remote_mirrors_as_failed!
    remote_mirrors.stuck.update_all(
      update_status: :failed,
      last_error: 'The remote mirror took to long to complete.',
      last_update_at: Time.now
    )
  end

  def mark_remote_mirrors_for_removal
    remote_mirrors.each(&:mark_for_delete_if_blank_url)
  end

  def remote_mirror_available?
    remote_mirror_available_overridden ||
      ::Gitlab::CurrentSettings.mirror_available
  end

798
  def check_limit
Douwe Maan's avatar
Douwe Maan committed
799
    unless creator.can_create_project? || namespace.kind == 'group'
800 801 802
      projects_limit = creator.projects_limit

      if projects_limit == 0
Phil Hughes's avatar
Phil Hughes committed
803
        self.errors.add(:limit_reached, "Personal project creation is not allowed. Please contact your administrator with questions")
804
      else
Phil Hughes's avatar
Phil Hughes committed
805
        self.errors.add(:limit_reached, "Your project limit is #{projects_limit} projects! Please contact your administrator to increase it")
806
      end
807 808
    end
  rescue
809
    self.errors.add(:base, "Can't check your ability to create project")
gitlabhq's avatar
gitlabhq committed
810 811
  end

812 813 814 815 816 817 818 819 820 821 822 823 824
  def visibility_level_allowed_by_group
    return if visibility_level_allowed_by_group?

    level_name = Gitlab::VisibilityLevel.level_name(self.visibility_level).downcase
    group_level_name = Gitlab::VisibilityLevel.level_name(self.group.visibility_level).downcase
    self.errors.add(:visibility_level, "#{level_name} is not allowed in a #{group_level_name} group.")
  end

  def visibility_level_allowed_as_fork
    return if visibility_level_allowed_as_fork?

    level_name = Gitlab::VisibilityLevel.level_name(self.visibility_level).downcase
    self.errors.add(:visibility_level, "#{level_name} is not allowed since the fork source project has lower visibility.")
825 826
  end

827 828 829 830 831 832 833 834 835 836
  def check_wiki_path_conflict
    return if path.blank?

    path_to_check = path.ends_with?('.wiki') ? path.chomp('.wiki') : "#{path}.wiki"

    if Project.where(namespace_id: namespace_id, path: path_to_check).exists?
      errors.add(:name, 'has already been taken')
    end
  end

Rob Watson's avatar
Rob Watson committed
837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856
  def pages_https_only
    return false unless Gitlab.config.pages.external_https

    super
  end

  def pages_https_only?
    return false unless Gitlab.config.pages.external_https

    super
  end

  def validate_pages_https_only
    return unless pages_https_only?

    unless pages_domains.all?(&:https?)
      errors.add(:pages_https_only, "cannot be enabled unless all domains have TLS certificates")
    end
  end

857
  def to_param
858 859 860 861 862
    if persisted? && errors.include?(:path)
      path_was
    else
      path
    end
863 864
  end

865
  # `from` argument can be a Namespace or Project.
866 867
  def to_reference(from = nil, full: false)
    if full || cross_namespace_reference?(from)
868
      full_path
869 870 871
    elsif cross_project_reference?(from)
      path
    end
872 873
  end

874 875
  def to_human_reference(from = nil)
    if cross_namespace_reference?(from)
876
      name_with_namespace
877
    elsif cross_project_reference?(from)
878 879
      name
    end
880 881
  end

882
  def web_url
883
    Gitlab::Routing.url_helpers.project_url(self)
884 885
  end

886
  def new_issuable_address(author, address_type)
887
    return unless Gitlab::IncomingEmail.supports_issue_creation? && author
888

889 890
    author.ensure_incoming_email_token!

891
    suffix = address_type == 'merge_request' ? '+merge-request' : ''
892
    Gitlab::IncomingEmail.reply_address(
893
      "#{full_path}#{suffix}+#{author.incoming_email_token}")
894 895
  end

896
  def build_commit_note(commit)
897
    notes.new(commit_id: commit.id, noteable_type: 'Commit')
gitlabhq's avatar
gitlabhq committed
898
  end
Nihad Abbasov's avatar
Nihad Abbasov committed
899

900
  def last_activity
901
    last_event
gitlabhq's avatar
gitlabhq committed
902 903 904
  end

  def last_activity_date
905
    [last_activity_at, last_repository_updated_at, updated_at].compact.max
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
906
  end
907

908 909 910
  def project_id
    self.id
  end
randx's avatar
randx committed
911

912
  def get_issue(issue_id, current_user)
913 914 915 916 917
    issue = IssuesFinder.new(current_user, project_id: id).find_by(iid: issue_id) if issues_enabled?

    if issue
      issue
    elsif external_issue_tracker
Robert Speicher's avatar
Robert Speicher committed
918
      ExternalIssue.new(issue_id, self)
919 920 921
    end
  end

Robert Speicher's avatar
Robert Speicher committed
922
  def issue_exists?(issue_id)
923
    get_issue(issue_id)
Robert Speicher's avatar
Robert Speicher committed
924 925
  end

926
  def default_issue_tracker
927
    gitlab_issue_tracker_service || create_gitlab_issue_tracker_service
928 929 930 931 932 933 934 935 936 937
  end

  def issues_tracker
    if external_issue_tracker
      external_issue_tracker
    else
      default_issue_tracker
    end
  end

938
  def external_issue_reference_pattern
939
    external_issue_tracker.class.reference_pattern(only_long: issues_enabled?)
940 941
  end

942
  def default_issues_tracker?
943
    !external_issue_tracker
944 945 946
  end

  def external_issue_tracker
947 948 949 950 951 952 953 954 955 956 957 958 959 960
    if has_external_issue_tracker.nil? # To populate existing projects
      cache_has_external_issue_tracker
    end

    if has_external_issue_tracker?
      return @external_issue_tracker if defined?(@external_issue_tracker)

      @external_issue_tracker = services.external_issue_trackers.first
    else
      nil
    end
  end

  def cache_has_external_issue_tracker
961
    update_column(:has_external_issue_tracker, services.external_issue_trackers.any?) if Gitlab::Database.read_write?
962 963
  end

964 965 966 967
  def has_wiki?
    wiki_enabled? || has_external_wiki?
  end

968 969 970 971 972 973 974 975 976 977 978 979 980
  def external_wiki
    if has_external_wiki.nil?
      cache_has_external_wiki # Populate
    end

    if has_external_wiki
      @external_wiki ||= services.external_wikis.first
    else
      nil
    end
  end

  def cache_has_external_wiki
981
    update_column(:has_external_wiki, services.external_wikis.any?) if Gitlab::Database.read_write?
982 983
  end

984
  def find_or_initialize_services(exceptions: [])
985 986
    services_templates = Service.where(template: true)

987 988 989
    available_services_names = Service.available_services_names - exceptions

    available_services_names.map do |service_name|
990
      service = find_service(services, service_name)
991

992 993 994
      if service
        service
      else
995 996 997 998
        # We should check if template for the service exists
        template = find_service(services_templates, service_name)

        if template.nil?
999
          # If no template, we should create an instance. Ex `build_gitlab_ci_service`
1000
          public_send("build_#{service_name}_service") # rubocop:disable GitlabSecurity/PublicSend
1001
        else
1002
          Service.build_from_template(id, template)
1003 1004
        end
      end
1005 1006 1007
    end
  end

1008 1009 1010 1011
  def find_or_initialize_service(name)
    find_or_initialize_services.find { |service| service.to_param == name }
  end

1012 1013
  def create_labels
    Label.templates.each do |label|
1014
      params = label.attributes.except('id', 'template', 'created_at', 'updated_at')
1015
      Labels::FindOrCreateService.new(nil, self, params).execute(skip_authorization: true)
1016 1017 1018
    end
  end

1019 1020 1021
  def find_service(list, name)
    list.find { |service| service.to_param == name }
  end
1022

1023
  def ci_services
1024
    services.where(category: :ci)
1025 1026 1027
  end

  def ci_service
1028
    @ci_service ||= ci_services.reorder(nil).find_by(active: true)
1029 1030
  end

1031 1032 1033 1034 1035
  def monitoring_services
    services.where(category: :monitoring)
  end

  def monitoring_service
1036
    @monitoring_service ||= monitoring_services.reorder(nil).find_by(active: true)
1037 1038
  end

Drew Blessing's avatar
Drew Blessing committed
1039 1040 1041 1042
  def jira_tracker?
    issues_tracker.to_param == 'jira'
  end

1043
  def avatar_in_git
1044
    repository.avatar
1045 1046
  end

1047
  def avatar_url(**args)
1048
    Gitlab::Routing.url_helpers.project_avatar_url(self) if avatar_in_git
sue445's avatar
sue445 committed
1049 1050
  end

1051 1052 1053 1054 1055
  # For compatibility with old code
  def code
    path
  end

1056
  def items_for(entity)
1057 1058 1059 1060 1061 1062 1063
    case entity
    when 'issue' then
      issues
    when 'merge_request' then
      merge_requests
    end
  end
1064

1065
  def send_move_instructions(old_path_with_namespace)
1066 1067
    # New project path needs to be committed to the DB or notification will
    # retrieve stale information
1068 1069 1070
    run_after_commit do
      NotificationService.new.project_was_moved(self, old_path_with_namespace)
    end
1071
  end
1072 1073

  def owner
1074 1075
    if group
      group
1076
    else
1077
      namespace.try(:owner)
1078 1079
    end
  end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
1080

1081
  def execute_hooks(data, hooks_scope = :push_hooks)
1082
    run_after_commit_or_now do
1083
      hooks.hooks_for(hooks_scope).each do |hook|
1084 1085
        hook.async_execute(data, hooks_scope.to_s)
      end
1086

1087 1088
      SystemHooksService.new.execute_hooks(data, hooks_scope)
    end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
1089 1090
  end

1091 1092
  def execute_services(data, hooks_scope = :push_hooks)
    # Call only service hooks that are active for this scope
1093 1094 1095 1096
    run_after_commit_or_now do
      services.public_send(hooks_scope).each do |service| # rubocop:disable GitlabSecurity/PublicSend
        service.async_execute(data)
      end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
1097 1098 1099 1100
    end
  end

  def valid_repo?
1101
    repository.exists?
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
1102
  rescue
1103
    errors.add(:path, 'Invalid repository path')
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
1104 1105 1106 1107
    false
  end

  def url_to_repo
1108
    gitlab_shell.url_to_repo(full_path)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
1109 1110 1111
  end

  def repo_exists?
1112 1113 1114 1115 1116 1117 1118
    strong_memoize(:repo_exists) do
      begin
        repository.exists?
      rescue
        false
      end
    end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
1119 1120 1121
  end

  def root_ref?(branch)
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
1122
    repository.root_ref == branch
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
1123 1124 1125 1126 1127 1128
  end

  def ssh_url_to_repo
    url_to_repo
  end

1129 1130
  def http_url_to_repo
    "#{web_url}.git"
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
1131 1132
  end

1133
  def forked?
1134 1135 1136 1137 1138
    return true if fork_network && fork_network.root_project != self

    # TODO: Use only the above conditional using the `fork_network`
    # This is the old conditional that looks at the `forked_project_link`, we
    # fall back to this while we're migrating the new models
1139 1140
    !(forked_project_link.nil? || forked_project_link.forked_from_project.nil?)
  end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
1141

1142
  def fork_source
1143 1144
    return nil unless forked?

1145 1146 1147
    forked_from_project || fork_network&.root_project
  end

1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159
  def lfs_storage_project
    @lfs_storage_project ||= begin
      result = self

      # TODO: Make this go to the fork_network root immeadiatly
      # dependant on the discussion in: https://gitlab.com/gitlab-org/gitlab-ce/issues/39769
      result = result.fork_source while result&.forked?

      result || self
    end
  end

1160 1161 1162 1163 1164 1165 1166 1167 1168 1169
  # This will return all `lfs_objects` that are accessible to the project.
  # So this might be `self.lfs_objects` if the project is not part of a fork
  # network, or it is the base of the fork network.
  #
  # TODO: refactor this to get the correct lfs objects when implementing
  #       https://gitlab.com/gitlab-org/gitlab-ce/issues/39769
  def all_lfs_objects
    lfs_storage_project.lfs_objects
  end

1170 1171 1172 1173
  def personal?
    !group
  end

1174 1175 1176 1177 1178 1179
  # Expires various caches before a project is renamed.
  def expire_caches_before_rename(old_path)
    repo = Repository.new(old_path, self)
    wiki = Repository.new("#{old_path}.wiki", self)

    if repo.exists?
1180
      repo.before_delete
1181 1182 1183
    end

    if wiki.exists?
1184
      wiki.before_delete
1185 1186 1187
    end
  end

1188
  # Check if repository already exists on disk
1189 1190
  def check_repository_path_availability
    return true if skip_disk_validation
1191
    return false unless repository_storage
1192 1193 1194

    expires_full_path_cache # we need to clear cache to validate renames correctly

1195 1196 1197
    # Check if repository with same path already exists on disk we can
    # skip this for the hashed storage because the path does not change
    if legacy_storage? && repository_with_same_path_already_exists?
1198 1199 1200 1201 1202
      errors.add(:base, 'There is already a repository with that name on disk')
      return false
    end

    true
1203 1204
  rescue GRPC::Internal # if the path is too long
    false
1205 1206
  end

1207 1208 1209 1210
  def create_repository(force: false)
    # Forked import is handled asynchronously
    return if forked? && !force

1211
    if gitlab_shell.create_repository(repository_storage, disk_path)
1212 1213 1214 1215 1216 1217 1218 1219
      repository.after_create
      true
    else
      errors.add(:base, 'Failed to create repository via gitlab-shell')
      false
    end
  end

1220 1221
  def hook_attrs(backward: true)
    attrs = {
1222
      id: id,
Kirill Zaitsev's avatar
Kirill Zaitsev committed
1223
      name: name,
1224
      description: description,
Kirilll Zaitsev's avatar
Kirilll Zaitsev committed
1225
      web_url: web_url,
1226
      avatar_url: avatar_url(only_path: false),
1227 1228
      git_ssh_url: ssh_url_to_repo,
      git_http_url: http_url_to_repo,
Kirill Zaitsev's avatar
Kirill Zaitsev committed
1229
      namespace: namespace.name,
1230
      visibility_level: visibility_level,
1231
      path_with_namespace: full_path,
1232
      default_branch: default_branch,
1233
      ci_config_path: ci_config_path
Kirill Zaitsev's avatar
Kirill Zaitsev committed
1234
    }
1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246

    # Backward compatibility
    if backward
      attrs.merge!({
                    homepage: web_url,
                    url: url_to_repo,
                    ssh_url: ssh_url_to_repo,
                    http_url: http_url_to_repo
                  })
    end

    attrs
Kirill Zaitsev's avatar
Kirill Zaitsev committed
1247 1248
  end

1249
  def project_member(user)
1250 1251 1252 1253 1254
    if project_members.loaded?
      project_members.find { |member| member.user_id == user.id }
    else
      project_members.find_by(user_id: user)
    end
1255
  end
1256 1257 1258 1259

  def default_branch
    @default_branch ||= repository.root_ref if repository.exists?
  end
1260 1261 1262 1263 1264

  def reload_default_branch
    @default_branch = nil
    default_branch
  end
1265

1266
  def visibility_level_field
1267
    :visibility_level
1268
  end
1269 1270 1271 1272 1273 1274 1275 1276

  def archive!
    update_attribute(:archived, true)
  end

  def unarchive!
    update_attribute(:archived, false)
  end
1277

1278
  def change_head(branch)
1279 1280
    if repository.branch_exists?(branch)
      repository.before_change_head
1281
      repository.raw_repository.write_ref('HEAD', "refs/heads/#{branch}", shell: false)
1282 1283 1284 1285 1286 1287 1288
      repository.copy_gitattributes(branch)
      repository.after_change_head
      reload_default_branch
    else
      errors.add(:base, "Could not change HEAD: branch '#{branch}' does not exist")
      false
    end
1289
  end
1290

1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303
  def forked_from?(other_project)
    forked? && forked_from_project == other_project
  end

  def in_fork_network_of?(other_project)
    # TODO: Remove this in a next release when all fork_networks are populated
    # This makes sure all MergeRequests remain valid while the projects don't
    # have a fork_network yet.
    return true if forked_from?(other_project)

    return false if fork_network.nil? || other_project.fork_network.nil?

    fork_network == other_project.fork_network
1304
  end
1305

1306 1307 1308
  def origin_merge_requests
    merge_requests.where(source_project_id: self.id)
  end
1309

1310
  def ensure_repository
1311
    create_repository(force: true) unless repository_exists?
1312 1313
  end

1314 1315 1316 1317
  def repository_exists?
    !!repository.exists?
  end

1318 1319 1320 1321
  def wiki_repository_exists?
    wiki.repository_exists?
  end

1322
  # update visibility_level of forks
1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333
  def update_forks_visibility_level
    return unless visibility_level < visibility_level_was

    forks.each do |forked_project|
      if forked_project.visibility_level > visibility_level
        forked_project.visibility_level = visibility_level
        forked_project.save!
      end
    end
  end

1334 1335 1336
  def create_wiki
    ProjectWiki.new(self, self.owner).wiki
    true
1337
  rescue ProjectWiki::CouldNotCreateWikiError
1338
    errors.add(:base, 'Failed create wiki')
1339 1340
    false
  end
1341

1342 1343 1344 1345
  def wiki
    @wiki ||= ProjectWiki.new(self, self.owner)
  end

Drew Blessing's avatar
Drew Blessing committed
1346 1347 1348 1349
  def jira_tracker_active?
    jira_tracker? && jira_service.active
  end

1350
  def allowed_to_share_with_group?
1351
    !namespace.share_with_group_lock
1352 1353
  end

1354 1355 1356
  def pipeline_for(ref, sha = nil)
    sha ||= commit(ref).try(:sha)

1357
    return unless sha
1358

1359
    pipelines.order(id: :desc).find_by(sha: sha, ref: ref)
1360 1361
  end

1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378
  def latest_successful_pipeline_for_default_branch
    if defined?(@latest_successful_pipeline_for_default_branch)
      return @latest_successful_pipeline_for_default_branch
    end

    @latest_successful_pipeline_for_default_branch =
      pipelines.latest_successful_for(default_branch)
  end

  def latest_successful_pipeline_for(ref = nil)
    if ref && ref != default_branch
      pipelines.latest_successful_for(ref)
    else
      latest_successful_pipeline_for_default_branch
    end
  end

1379
  def enable_ci
1380
    project_feature.update_attribute(:builds_access_level, ProjectFeature::ENABLED)
1381
  end
Marin Jankovski's avatar
Marin Jankovski committed
1382

1383 1384 1385 1386
  def shared_runners_available?
    shared_runners_enabled?
  end

1387
  def shared_runners
1388
    @shared_runners ||= shared_runners_available? ? Ci::Runner.shared : Ci::Runner.none
1389 1390
  end

1391
  def group_runners
1392
    @group_runners ||= group_runners_enabled? ? Ci::Runner.belonging_to_parent_group_of_project(self.id) : Ci::Runner.none
1393 1394
  end

1395 1396 1397 1398 1399
  def all_runners
    union = Gitlab::SQL::Union.new([runners, group_runners, shared_runners])
    Ci::Runner.from("(#{union.to_sql}) ci_runners")
  end

1400
  def any_runners?(&block)
1401
    all_runners.active.any?(&block)
1402 1403
  end

1404
  def valid_runners_token?(token)
James Lopez's avatar
James Lopez committed
1405
    self.runners_token && ActiveSupport::SecurityUtils.variable_size_secure_compare(token, self.runners_token)
Kamil Trzcinski's avatar
Kamil Trzcinski committed
1406 1407
  end

1408
  def open_issues_count
1409 1410 1411 1412 1413
    Projects::OpenIssuesCountService.new(self).count
  end

  def open_merge_requests_count
    Projects::OpenMergeRequestsCountService.new(self).count
1414
  end
1415

1416
  def visibility_level_allowed_as_fork?(level = self.visibility_level)
Douwe Maan's avatar
Douwe Maan committed
1417
    return true unless forked?
1418

Douwe Maan's avatar
Douwe Maan committed
1419 1420
    # self.forked_from_project will be nil before the project is saved, so
    # we need to go through the relation
1421
    original_project = forked_project_link&.forked_from_project
Douwe Maan's avatar
Douwe Maan committed
1422 1423 1424
    return true unless original_project

    level <= original_project.visibility_level
1425
  end
1426

1427 1428
  def visibility_level_allowed_by_group?(level = self.visibility_level)
    return true unless group
1429

1430
    level <= group.visibility_level
Marin Jankovski's avatar
Marin Jankovski committed
1431
  end
1432

1433 1434
  def visibility_level_allowed?(level = self.visibility_level)
    visibility_level_allowed_as_fork?(level) && visibility_level_allowed_by_group?(level)
Felipe Artur's avatar
Felipe Artur committed
1435 1436
  end

1437 1438 1439
  def runners_token
    ensure_runners_token!
  end
1440

1441 1442 1443
  def pages_deployed?
    Dir.exist?(public_pages_path)
  end
1444

1445
  def pages_group_url
1446
    # The host in URL always needs to be downcased
1447 1448
    Gitlab.config.pages.url.sub(%r{^https?://}) do |prefix|
      "#{prefix}#{pages_subdomain}."
1449
    end.downcase
1450 1451 1452 1453 1454
  end

  def pages_url
    url = pages_group_url
    url_path = full_path.partition('/').last
1455

1456
    # If the project path is the same as host, we serve it as group page
1457
    return url if url == "#{Settings.pages.protocol}://#{url_path}"
1458 1459 1460

    "#{url}/#{url_path}"
  end
1461

1462 1463
  def pages_subdomain
    full_path.partition('/').first
1464
  end
Kamil Trzcinski's avatar
Kamil Trzcinski committed
1465 1466

  def pages_path
1467 1468
    # TODO: when we migrate Pages to work with new storage types, change here to use disk_path
    File.join(Settings.pages.path, full_path)
Kamil Trzcinski's avatar
Kamil Trzcinski committed
1469 1470 1471 1472 1473 1474
  end

  def public_pages_path
    File.join(pages_path, 'public')
  end

1475 1476 1477 1478
  def pages_available?
    Gitlab.config.pages.enabled && !namespace.subgroup?
  end

1479
  def remove_private_deploy_keys
1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491
    exclude_keys_linked_to_other_projects = <<-SQL
      NOT EXISTS (
        SELECT 1
        FROM deploy_keys_projects dkp2
        WHERE dkp2.deploy_key_id = deploy_keys_projects.deploy_key_id
        AND dkp2.project_id != deploy_keys_projects.project_id
      )
    SQL

    deploy_keys.where(public: false)
               .where(exclude_keys_linked_to_other_projects)
               .delete_all
1492 1493
  end

1494
  # TODO: what to do here when not using Legacy Storage? Do we still need to rename and delay removal?
Kamil Trzcinski's avatar
Kamil Trzcinski committed
1495
  def remove_pages
1496 1497 1498
    # Projects with a missing namespace cannot have their pages removed
    return unless namespace

1499 1500
    ::Projects::UpdatePagesConfigurationService.new(self).execute

1501 1502 1503
    # 1. We rename pages to temporary directory
    # 2. We wait 5 minutes, due to NFS caching
    # 3. We asynchronously remove pages with force
Kamil Trzcinski's avatar
Kamil Trzcinski committed
1504
    temp_path = "#{path}.#{SecureRandom.hex}.deleted"
1505

1506 1507
    if Gitlab::PagesTransfer.new.rename_project(path, temp_path, namespace.full_path)
      PagesWorker.perform_in(5.minutes, :remove, namespace.full_path, temp_path)
1508
    end
Kamil Trzcinski's avatar
Kamil Trzcinski committed
1509 1510
  end

1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537
  def rename_repo
    new_full_path = build_full_path

    Rails.logger.error "Attempting to rename #{full_path_was} -> #{new_full_path}"

    if has_container_registry_tags?
      Rails.logger.error "Project #{full_path_was} cannot be renamed because container registry tags are present!"

      # we currently doesn't support renaming repository if it contains images in container registry
      raise StandardError.new('Project cannot be renamed, because images are present in its container registry')
    end

    expire_caches_before_rename(full_path_was)

    if storage.rename_repo
      Gitlab::AppLogger.info "Project was renamed: #{full_path_was} -> #{new_full_path}"
      rename_repo_notify!
      after_rename_repo
    else
      Rails.logger.error "Repository could not be renamed: #{full_path_was} -> #{new_full_path}"

      # if we cannot move namespace directory we should rollback
      # db changes in order to prevent out of sync between db and fs
      raise StandardError.new('repository cannot be renamed')
    end
  end

1538
  def after_rename_repo
1539
    write_repository_config
1540

1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552
    path_before_change = previous_changes['path'].first

    # We need to check if project had been rolled out to move resource to hashed storage or not and decide
    # if we need execute any take action or no-op.

    unless hashed_storage?(:attachments)
      Gitlab::UploadsTransfer.new.rename_project(path_before_change, self.path, namespace.full_path)
    end

    Gitlab::PagesTransfer.new.rename_project(path_before_change, self.path, namespace.full_path)
  end

1553 1554 1555 1556
  def write_repository_config(gl_full_path: full_path)
    # We'd need to keep track of project full path otherwise directory tree
    # created with hashed storage enabled cannot be usefully imported using
    # the import rake task.
1557
    repository.raw_repository.write_config(full_path: gl_full_path)
1558
  rescue Gitlab::Git::Repository::NoRepository => e
1559
    Rails.logger.error("Error writing to .git/config for project #{full_path} (#{id}): #{e.message}.")
1560
    nil
1561 1562
  end

1563
  def rename_repo_notify!
1564 1565
    # When we import a project overwriting the original project, there
    # is a move operation. In that case we don't want to send the instructions.
1566
    send_move_instructions(full_path_was) unless import_started?
1567 1568 1569 1570 1571 1572 1573 1574
    expires_full_path_cache

    self.old_path_with_namespace = full_path_was
    SystemHooksService.new.execute_hooks_for(self, :rename)

    reload_repository!
  end

1575 1576 1577 1578 1579
  def after_import
    repository.after_import
    import_finish
    remove_import_jid
    update_project_counter_caches
1580
    after_create_default_branch
1581
    refresh_markdown_cache!
1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594
  end

  def update_project_counter_caches
    classes = [
      Projects::OpenIssuesCountService,
      Projects::OpenMergeRequestsCountService
    ]

    classes.each do |klass|
      klass.new(self).refresh_cache
    end
  end

1595 1596 1597 1598 1599 1600
  def after_create_default_branch
    return unless default_branch

    # Ensure HEAD points to the default branch in case it is not master
    change_head(default_branch)

1601
    if Gitlab::CurrentSettings.default_branch_protection != Gitlab::Access::PROTECTION_NONE && !ProtectedBranch.protected?(self, default_branch)
1602 1603 1604
      params = {
        name: default_branch,
        push_access_levels_attributes: [{
1605
          access_level: Gitlab::CurrentSettings.default_branch_protection == Gitlab::Access::PROTECTION_DEV_CAN_PUSH ? Gitlab::Access::DEVELOPER : Gitlab::Access::MASTER
1606 1607
        }],
        merge_access_levels_attributes: [{
1608
          access_level: Gitlab::CurrentSettings.default_branch_protection == Gitlab::Access::PROTECTION_DEV_CAN_MERGE ? Gitlab::Access::DEVELOPER : Gitlab::Access::MASTER
1609 1610 1611 1612 1613 1614 1615
        }]
      }

      ProtectedBranches::CreateService.new(self, creator, params).execute(skip_authorization: true)
    end
  end

1616 1617 1618 1619
  def remove_import_jid
    return unless import_jid

    Gitlab::SidekiqStatus.unset(import_jid)
1620 1621

    import_state.update_column(:jid, nil)
1622 1623
  end

Josh Frye's avatar
Josh Frye committed
1624 1625
  def running_or_pending_build_count(force: false)
    Rails.cache.fetch(['projects', id, 'running_or_pending_build_count'], force: force) do
1626 1627 1628
      builds.running_or_pending.count(:all)
    end
  end
1629

1630
  # Lazy loading of the `pipeline_status` attribute
1631
  def pipeline_status
1632
    @pipeline_status ||= Gitlab::Cache::Ci::ProjectPipelineStatus.load_for_project(self)
1633 1634
  end

1635
  def mark_import_as_failed(error_message)
1636 1637 1638
    original_errors = errors.dup
    sanitized_message = Gitlab::UrlSanitizer.sanitize(error_message)

1639
    import_fail
1640 1641

    import_state.update_column(:last_error, sanitized_message)
1642 1643 1644 1645
  rescue ActiveRecord::ActiveRecordError => e
    Rails.logger.error("Error setting import status to failed: #{e.message}. Original error: #{sanitized_message}")
  ensure
    @errors = original_errors
1646
  end
James Lopez's avatar
James Lopez committed
1647

1648 1649
  def add_export_job(current_user:, after_export_strategy: nil, params: {})
    job_id = ProjectExportWorker.perform_async(current_user.id, self.id, after_export_strategy, params)
1650 1651 1652 1653 1654 1655 1656

    if job_id
      Rails.logger.info "Export job started for project ID #{self.id} with job ID #{job_id}"
    else
      Rails.logger.error "Export job failed to start for project ID #{self.id}"
    end
  end
James Lopez's avatar
James Lopez committed
1657

1658 1659
  def import_export_shared
    @import_export_shared ||= Gitlab::ImportExport::Shared.new(self)
1660 1661
  end

James Lopez's avatar
James Lopez committed
1662
  def export_path
1663 1664
    return nil unless namespace.present? || hashed_storage?(:repository)

1665
    import_export_shared.archive_path
James Lopez's avatar
James Lopez committed
1666
  end
1667 1668 1669 1670 1671

  def export_project_path
    Dir.glob("#{export_path}/*export.tar.gz").max_by { |f| File.ctime(f) }
  end

1672 1673 1674
  def export_status
    if export_in_progress?
      :started
1675 1676
    elsif after_export_in_progress?
      :after_export_action
1677 1678 1679 1680 1681 1682 1683 1684
    elsif export_project_path
      :finished
    else
      :none
    end
  end

  def export_in_progress?
1685
    import_export_shared.active_export_count > 0
1686 1687
  end

1688 1689 1690 1691
  def after_export_in_progress?
    import_export_shared.after_export_in_progress?
  end

1692
  def remove_exports
1693 1694 1695
    return nil unless export_path.present?

    FileUtils.rm_rf(export_path)
1696
  end
1697

1698 1699 1700 1701 1702 1703
  def remove_exported_project_file
    return unless export_project_path.present?

    FileUtils.rm_f(export_project_path)
  end

1704 1705 1706 1707
  def full_path_slug
    Gitlab::Utils.slugify(full_path.to_s)
  end

1708
  def has_ci?
1709
    repository.gitlab_ci_yml || auto_devops_enabled?
1710 1711
  end

1712
  def predefined_variables
1713 1714
    visibility = Gitlab::VisibilityLevel.string_level(visibility_level)

1715 1716 1717 1718 1719 1720 1721 1722 1723 1724
    Gitlab::Ci::Variables::Collection.new
      .append(key: 'CI_PROJECT_ID', value: id.to_s)
      .append(key: 'CI_PROJECT_NAME', value: path)
      .append(key: 'CI_PROJECT_PATH', value: full_path)
      .append(key: 'CI_PROJECT_PATH_SLUG', value: full_path_slug)
      .append(key: 'CI_PROJECT_NAMESPACE', value: namespace.full_path)
      .append(key: 'CI_PROJECT_URL', value: web_url)
      .append(key: 'CI_PROJECT_VISIBILITY', value: visibility)
      .concat(container_registry_variables)
      .concat(auto_devops_variables)
1725 1726 1727
  end

  def container_registry_variables
1728
    Gitlab::Ci::Variables::Collection.new.tap do |variables|
1729
      break variables unless Gitlab.config.registry.enabled
1730

1731
      variables.append(key: 'CI_REGISTRY', value: Gitlab.config.registry.host_port)
1732

1733
      if container_registry_enabled?
1734
        variables.append(key: 'CI_REGISTRY_IMAGE', value: container_registry_url)
1735
      end
Kamil Trzcinski's avatar
Kamil Trzcinski committed
1736
    end
1737 1738
  end

Lin Jen-Shin's avatar
Lin Jen-Shin committed
1739 1740
  def secret_variables_for(ref:, environment: nil)
    # EE would use the environment
1741 1742 1743 1744 1745 1746
    if protected_for?(ref)
      variables
    else
      variables.unprotected
    end
  end
1747

1748
  def protected_for?(ref)
1749 1750 1751
    if repository.branch_exists?(ref)
      ProtectedBranch.protected?(self, ref)
    elsif repository.tag_exists?(ref)
1752
      ProtectedTag.protected?(self, ref)
1753
    end
1754
  end
1755

1756 1757
  def deployment_variables(environment: nil)
    deployment_platform(environment: environment)&.predefined_variables || []
1758 1759
  end

1760 1761 1762
  def auto_devops_variables
    return [] unless auto_devops_enabled?

1763
    (auto_devops || build_auto_devops)&.predefined_variables
1764 1765
  end

1766
  def append_or_update_attribute(name, value)
1767
    old_values = public_send(name.to_s) # rubocop:disable GitlabSecurity/PublicSend
1768 1769 1770 1771 1772 1773

    if Project.reflect_on_association(name).try(:macro) == :has_many && old_values.any?
      update_attribute(name, old_values + value)
    else
      update_attribute(name, value)
    end
1774 1775 1776

  rescue ActiveRecord::RecordNotSaved => e
    handle_update_attribute_error(e, value)
1777 1778
  end

1779
  def pushes_since_gc
1780
    Gitlab::Redis::SharedState.with { |redis| redis.get(pushes_since_gc_redis_shared_state_key).to_i }
1781 1782 1783
  end

  def increment_pushes_since_gc
1784
    Gitlab::Redis::SharedState.with { |redis| redis.incr(pushes_since_gc_redis_shared_state_key) }
1785 1786 1787
  end

  def reset_pushes_since_gc
1788
    Gitlab::Redis::SharedState.with { |redis| redis.del(pushes_since_gc_redis_shared_state_key) }
1789 1790
  end

Douwe Maan's avatar
Douwe Maan committed
1791
  def route_map_for(commit_sha)
1792 1793
    @route_maps_by_commit ||= Hash.new do |h, sha|
      h[sha] = begin
Douwe Maan's avatar
Douwe Maan committed
1794
        data = repository.route_map_for(sha)
1795 1796
        next unless data

Douwe Maan's avatar
Douwe Maan committed
1797 1798 1799
        Gitlab::RouteMap.new(data)
      rescue Gitlab::RouteMap::FormatError
        nil
1800 1801 1802 1803 1804 1805 1806
      end
    end

    @route_maps_by_commit[commit_sha]
  end

  def public_path_for_source_path(path, commit_sha)
Douwe Maan's avatar
Douwe Maan committed
1807
    map = route_map_for(commit_sha)
1808 1809
    return unless map

Douwe Maan's avatar
Douwe Maan committed
1810
    map.public_path_for_source_path(path)
1811 1812
  end

1813 1814 1815 1816
  def parent_changed?
    namespace_id_changed?
  end

1817 1818 1819 1820 1821 1822 1823 1824
  def default_merge_request_target
    if forked_from_project&.merge_requests_enabled?
      forked_from_project
    else
      self
    end
  end

Felipe Artur's avatar
Felipe Artur committed
1825 1826 1827
  # Overridden on EE module
  def multiple_issue_boards_available?
    false
Felipe Artur's avatar
Felipe Artur committed
1828 1829 1830 1831 1832 1833
  end

  def issue_board_milestone_available?(user = nil)
    feature_available?(:issue_board_milestone, user)
  end

1834 1835 1836 1837
  def full_path_was
    File.join(namespace.full_path, previous_changes['path'].first)
  end

1838 1839
  alias_method :name_with_namespace, :full_name
  alias_method :human_name, :full_name
1840
  # @deprecated cannot remove yet because it has an index with its name in elasticsearch
1841 1842
  alias_method :path_with_namespace, :full_path

1843 1844 1845 1846
  def forks_count
    Projects::ForksCountService.new(self).count
  end

1847
  def legacy_storage?
1848 1849 1850
    [nil, 0].include?(self.storage_version)
  end

1851 1852 1853 1854
  # Check if Hashed Storage is enabled for the project with at least informed feature rolled out
  #
  # @param [Symbol] feature that needs to be rolled out for the project (:repository, :attachments)
  def hashed_storage?(feature)
1855 1856 1857
    raise ArgumentError, "Invalid feature" unless HASHED_STORAGE_FEATURES.include?(feature)

    self.storage_version && self.storage_version >= HASHED_STORAGE_FEATURES[feature]
1858 1859
  end

1860 1861 1862 1863
  def renamed?
    persisted? && path_changed?
  end

1864 1865 1866
  def merge_method
    if self.merge_requests_ff_only_enabled
      :ff
1867 1868
    elsif self.merge_requests_rebase_enabled
      :rebase_merge
1869 1870 1871 1872 1873 1874
    else
      :merge
    end
  end

  def merge_method=(method)
1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885
    case method.to_s
    when "ff"
      self.merge_requests_ff_only_enabled = true
      self.merge_requests_rebase_enabled = true
    when "rebase_merge"
      self.merge_requests_ff_only_enabled = false
      self.merge_requests_rebase_enabled = true
    when "merge"
      self.merge_requests_ff_only_enabled = false
      self.merge_requests_rebase_enabled = false
    end
1886 1887 1888
  end

  def ff_merge_must_be_possible?
1889
    self.merge_requests_ff_only_enabled || self.merge_requests_rebase_enabled
1890 1891
  end

1892
  def migrate_to_hashed_storage!
1893
    return if hashed_storage?(:repository)
1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913

    update!(repository_read_only: true)

    if repo_reference_count > 0 || wiki_reference_count > 0
      ProjectMigrateHashedStorageWorker.perform_in(Gitlab::ReferenceCounter::REFERENCE_EXPIRE_TIME, id)
    else
      ProjectMigrateHashedStorageWorker.perform_async(id)
    end
  end

  def storage_version=(value)
    super

    @storage = nil if storage_version_changed?
  end

  def gl_repository(is_wiki:)
    Gitlab::GlRepository.gl_repository(self, is_wiki)
  end

1914 1915 1916 1917
  def reference_counter(wiki: false)
    Gitlab::ReferenceCounter.new(gl_repository(is_wiki: wiki))
  end

1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928
  # Refreshes the expiration time of the associated import job ID.
  #
  # This method can be used by asynchronous importers to refresh the status,
  # preventing the StuckImportJobsWorker from marking the import as failed.
  def refresh_import_jid_expiration
    return unless import_jid

    Gitlab::SidekiqStatus
      .set(import_jid, StuckImportJobsWorker::IMPORT_JOBS_EXPIRATION)
  end

1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939
  def badges
    return project_badges unless group

    group_badges_rel = GroupBadge.where(group: group.self_and_ancestors)

    union = Gitlab::SQL::Union.new([project_badges.select(:id),
                                    group_badges_rel.select(:id)])

    Badge.where("id IN (#{union.to_sql})") # rubocop:disable GitlabSecurity/SqlInjection
  end

1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961
  def merge_requests_allowing_push_to_user(user)
    return MergeRequest.none unless user

    developer_access_exists = user.project_authorizations
                                .where('access_level >= ? ', Gitlab::Access::DEVELOPER)
                                .where('project_authorizations.project_id = merge_requests.target_project_id')
                                .limit(1)
                                .select(1)
    source_of_merge_requests.opened
      .where(allow_maintainer_to_push: true)
      .where('EXISTS (?)', developer_access_exists)
  end

  def branch_allows_maintainer_push?(user, branch_name)
    return false unless user

    cache_key = "user:#{user.id}:#{branch_name}:branch_allows_push"

    memoized_results = strong_memoize(:branch_allows_maintainer_push) do
      Hash.new do |result, cache_key|
        result[cache_key] = fetch_branch_allows_maintainer_push?(user, branch_name)
      end
1962 1963
    end

1964
    memoized_results[cache_key]
1965 1966
  end

1967 1968 1969 1970
  def licensed_features
    []
  end

1971 1972
  def toggle_ci_cd_settings!(settings_attribute)
    ci_cd_settings.toggle!(settings_attribute)
1973 1974
  end

1975
  def gitlab_deploy_token
1976
    @gitlab_deploy_token ||= deploy_tokens.gitlab_deploy_token
1977 1978
  end

1979 1980
  private

1981 1982
  def storage
    @storage ||=
1983
      if hashed_storage?(:repository)
1984 1985 1986 1987 1988
        Storage::HashedProject.new(self)
      else
        Storage::LegacyProject.new(self)
      end
  end
1989

1990
  def use_hashed_storage
1991
    if self.new_record? && Gitlab::CurrentSettings.hashed_storage_enabled
1992
      self.storage_version = LATEST_STORAGE_VERSION
1993 1994 1995
    end
  end

1996
  def repo_reference_count
1997
    reference_counter.value
1998 1999 2000
  end

  def wiki_reference_count
2001
    reference_counter(wiki: true).value
2002 2003
  end

2004 2005 2006
  def check_repository_absence!
    return if skip_disk_validation

2007
    if repository_storage.blank? || repository_with_same_path_already_exists?
2008 2009 2010 2011 2012 2013
      errors.add(:base, 'There is already a repository with that name on disk')
      throw :abort
    end
  end

  def repository_with_same_path_already_exists?
2014
    gitlab_shell.exists?(repository_storage, "#{disk_path}.git")
2015 2016
  end

2017 2018 2019 2020 2021 2022 2023 2024 2025
  # set last_activity_at to the same as created_at
  def set_last_activity_at
    update_column(:last_activity_at, self.created_at)
  end

  def set_last_repository_updated_at
    update_column(:last_repository_updated_at, self.created_at)
  end

2026
  def cross_namespace_reference?(from)
2027 2028 2029 2030 2031
    case from
    when Project
      namespace != from.namespace
    when Namespace
      namespace != from
2032 2033 2034
    end
  end

2035
  # Check if a reference is being done cross-project
2036 2037 2038 2039
  def cross_project_reference?(from)
    return true if from.is_a?(Namespace)

    from && self != from
2040 2041
  end

2042
  def pushes_since_gc_redis_shared_state_key
2043 2044 2045
    "projects/#{id}/pushes_since_gc"
  end

2046 2047 2048 2049 2050 2051 2052
  # Similar to the normal callbacks that hook into the life cycle of an
  # Active Record object, you can also define callbacks that get triggered
  # when you add an object to an association collection. If any of these
  # callbacks throw an exception, the object will not be added to the
  # collection. Before you add a new board to the boards collection if you
  # already have 1, 2, or n it will fail, but it if you have 0 that is lower
  # than the number of permitted boards per project it won't fail.
2053
  def validate_board_limit(board)
2054
    raise BoardLimitExceeded, 'Number of permitted boards exceeded' if boards.size >= NUMBER_OF_PERMITTED_BOARDS
2055
  end
2056

2057 2058 2059 2060
  def update_project_statistics
    stats = statistics || build_statistics
    stats.update(namespace_id: namespace_id)
  end
2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075

  def check_pending_delete
    return if valid_attribute?(:name) && valid_attribute?(:path)
    return unless pending_delete_twin

    %i[route route.path name path].each do |error|
      errors.delete(error)
    end

    errors.add(:base, "The project is still being deleted. Please try again later.")
  end

  def pending_delete_twin
    return false unless path

2076
    Project.pending_delete.find_by_full_path(full_path)
2077
  end
2078 2079 2080 2081 2082 2083 2084 2085 2086

  ##
  # This method is here because of support for legacy container repository
  # which has exactly the same path like project does, but which might not be
  # persisted in `container_repositories` table.
  #
  def has_root_container_repository_tags?
    return false unless Gitlab.config.registry.enabled

2087
    ContainerRepository.build_root_repository(self).has_tags?
2088
  end
2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100

  def handle_update_attribute_error(ex, value)
    if ex.message.start_with?('Failed to replace')
      if value.respond_to?(:each)
        invalid = value.detect(&:invalid?)

        raise ex, ([ex.message] + invalid.errors.full_messages).join(' ') if invalid
      end
    end

    raise ex
  end
2101

2102
  def fetch_branch_allows_maintainer_push?(user, branch_name)
2103
    check_access = -> do
2104 2105
      next false if empty_repo?

2106 2107 2108 2109 2110 2111
      merge_request = source_of_merge_requests.opened
                        .where(allow_maintainer_to_push: true)
                        .find_by(source_branch: branch_name)
      merge_request&.can_be_merged_by?(user)
    end

2112
    if RequestStore.active?
2113
      RequestStore.fetch("project-#{id}:branch-#{branch_name}:user-#{user.id}:branch_allows_maintainer_push") do
2114
        check_access.call
2115 2116
      end
    else
2117
      check_access.call
2118 2119
    end
  end
gitlabhq's avatar
gitlabhq committed
2120
end