2018-08-03 07:15:25 +00:00
|
|
|
# frozen_string_literal: true
|
|
|
|
|
2015-08-26 01:42:46 +00:00
|
|
|
module Ci
|
2021-08-03 06:08:50 +00:00
|
|
|
class Pipeline < Ci::ApplicationRecord
|
2020-06-22 15:09:27 +00:00
|
|
|
include Ci::HasStatus
|
2016-08-30 08:09:41 +00:00
|
|
|
include Importable
|
2016-10-12 10:07:58 +00:00
|
|
|
include AfterCommitQueue
|
2017-03-28 20:27:16 +00:00
|
|
|
include Presentable
|
2020-12-16 12:09:53 +00:00
|
|
|
include Gitlab::Allowable
|
2017-10-03 08:12:28 +00:00
|
|
|
include Gitlab::OptimisticLocking
|
2018-03-21 08:33:14 +00:00
|
|
|
include Gitlab::Utils::StrongMemoize
|
2018-04-24 08:08:43 +00:00
|
|
|
include AtomicInternalId
|
2018-05-31 18:32:36 +00:00
|
|
|
include EnumWithNil
|
2020-03-13 15:09:21 +00:00
|
|
|
include Ci::HasRef
|
2019-02-20 06:37:49 +00:00
|
|
|
include ShaAttribute
|
2019-03-01 06:18:08 +00:00
|
|
|
include FromUnion
|
2019-12-06 18:07:44 +00:00
|
|
|
include UpdatedAtFilterable
|
2021-02-11 15:09:11 +00:00
|
|
|
include EachBatch
|
2021-05-14 12:10:58 +00:00
|
|
|
include FastDestroyAll::Helpers
|
2019-02-20 06:37:49 +00:00
|
|
|
|
2020-12-16 12:09:53 +00:00
|
|
|
MAX_OPEN_MERGE_REQUESTS_REFS = 4
|
|
|
|
|
2020-02-20 18:08:51 +00:00
|
|
|
PROJECT_ROUTE_AND_NAMESPACE_ROUTE = {
|
|
|
|
project: [:project_feature, :route, { namespace: :route }]
|
|
|
|
}.freeze
|
2020-08-26 15:10:29 +00:00
|
|
|
CONFIG_EXTENSION = '.gitlab-ci.yml'
|
|
|
|
DEFAULT_CONFIG_PATH = CONFIG_EXTENSION
|
2020-02-20 18:08:51 +00:00
|
|
|
|
2020-02-08 06:08:50 +00:00
|
|
|
BridgeStatusError = Class.new(StandardError)
|
|
|
|
|
2021-06-30 18:07:05 +00:00
|
|
|
paginates_per 15
|
|
|
|
|
2019-02-20 06:37:49 +00:00
|
|
|
sha_attribute :source_sha
|
|
|
|
sha_attribute :target_sha
|
2015-09-24 15:09:33 +00:00
|
|
|
|
2020-10-05 12:08:47 +00:00
|
|
|
# Ci::CreatePipelineService returns Ci::Pipeline so this is the only place
|
|
|
|
# where we can pass additional information from the service. This accessor
|
|
|
|
# is used for storing the processed CI YAML contents for linting purposes.
|
|
|
|
# There is an open issue to address this:
|
|
|
|
# https://gitlab.com/gitlab-org/gitlab/-/issues/259010
|
|
|
|
attr_accessor :merged_yaml
|
|
|
|
|
2018-12-05 14:39:15 +00:00
|
|
|
belongs_to :project, inverse_of: :all_pipelines
|
2016-07-15 13:42:29 +00:00
|
|
|
belongs_to :user
|
2017-03-18 11:46:56 +00:00
|
|
|
belongs_to :auto_canceled_by, class_name: 'Ci::Pipeline'
|
2017-05-07 22:35:56 +00:00
|
|
|
belongs_to :pipeline_schedule, class_name: 'Ci::PipelineSchedule'
|
2018-12-05 06:57:00 +00:00
|
|
|
belongs_to :merge_request, class_name: 'MergeRequest'
|
2019-08-09 09:40:45 +00:00
|
|
|
belongs_to :external_pull_request
|
2020-06-10 09:08:35 +00:00
|
|
|
belongs_to :ci_ref, class_name: 'Ci::Ref', foreign_key: :ci_ref_id, inverse_of: :pipelines
|
2016-07-15 13:42:29 +00:00
|
|
|
|
2020-11-11 00:08:58 +00:00
|
|
|
has_internal_id :iid, scope: :project, presence: false,
|
|
|
|
track_if: -> { !importing? },
|
|
|
|
ensure_if: -> { !importing? },
|
|
|
|
init: ->(pipeline, scope) do
|
|
|
|
if pipeline
|
|
|
|
pipeline.project&.all_pipelines&.maximum(:iid) || pipeline.project&.all_pipelines&.count
|
|
|
|
elsif scope
|
|
|
|
::Ci::Pipeline.where(**scope).maximum(:iid)
|
|
|
|
end
|
|
|
|
end
|
2018-04-24 08:08:43 +00:00
|
|
|
|
2018-05-22 11:03:42 +00:00
|
|
|
has_many :stages, -> { order(position: :asc) }, inverse_of: :pipeline
|
2018-02-21 04:34:38 +00:00
|
|
|
has_many :statuses, class_name: 'CommitStatus', foreign_key: :commit_id, inverse_of: :pipeline
|
2019-12-24 15:07:44 +00:00
|
|
|
has_many :latest_statuses_ordered_by_stage, -> { latest.order(:stage_idx, :stage) }, class_name: 'CommitStatus', foreign_key: :commit_id, inverse_of: :pipeline
|
2020-09-28 09:09:35 +00:00
|
|
|
has_many :latest_statuses, -> { latest }, class_name: 'CommitStatus', foreign_key: :commit_id, inverse_of: :pipeline
|
2020-01-10 18:07:43 +00:00
|
|
|
has_many :processables, class_name: 'Ci::Processable', foreign_key: :commit_id, inverse_of: :pipeline
|
2020-06-16 12:09:00 +00:00
|
|
|
has_many :bridges, class_name: 'Ci::Bridge', foreign_key: :commit_id, inverse_of: :pipeline
|
2018-02-28 02:56:18 +00:00
|
|
|
has_many :builds, foreign_key: :commit_id, inverse_of: :pipeline
|
2020-06-04 12:08:21 +00:00
|
|
|
has_many :job_artifacts, through: :builds
|
2017-06-08 15:16:27 +00:00
|
|
|
has_many :trigger_requests, dependent: :destroy, foreign_key: :commit_id # rubocop:disable Cop/ActiveRecordDependent
|
2017-07-26 09:31:09 +00:00
|
|
|
has_many :variables, class_name: 'Ci::PipelineVariable'
|
2018-12-03 06:46:45 +00:00
|
|
|
has_many :deployments, through: :builds
|
|
|
|
has_many :environments, -> { distinct }, through: :deployments
|
2020-12-21 00:10:18 +00:00
|
|
|
has_many :latest_builds, -> { latest.with_project_and_metadata }, foreign_key: :commit_id, inverse_of: :pipeline, class_name: 'Ci::Build'
|
2021-05-12 00:10:27 +00:00
|
|
|
has_many :downloadable_artifacts, -> do
|
|
|
|
not_expired.or(where_exists(::Ci::Pipeline.artifacts_locked.where('ci_pipelines.id = ci_builds.commit_id'))).downloadable.with_job
|
|
|
|
end, through: :latest_builds, source: :job_artifacts
|
2017-03-28 20:04:14 +00:00
|
|
|
|
2020-06-29 12:09:20 +00:00
|
|
|
has_many :messages, class_name: 'Ci::PipelineMessage', inverse_of: :pipeline
|
|
|
|
|
2017-03-28 20:04:14 +00:00
|
|
|
# Merge requests for which the current pipeline is running against
|
|
|
|
# the merge request's latest commit.
|
2019-03-01 05:10:07 +00:00
|
|
|
has_many :merge_requests_as_head_pipeline, foreign_key: "head_pipeline_id", class_name: 'MergeRequest'
|
2015-08-26 01:42:46 +00:00
|
|
|
|
2020-07-22 00:09:26 +00:00
|
|
|
has_many :pending_builds, -> { pending }, foreign_key: :commit_id, class_name: 'Ci::Build', inverse_of: :pipeline
|
2019-12-24 15:07:44 +00:00
|
|
|
has_many :failed_builds, -> { latest.failed }, foreign_key: :commit_id, class_name: 'Ci::Build', inverse_of: :pipeline
|
2020-07-22 00:09:26 +00:00
|
|
|
has_many :retryable_builds, -> { latest.failed_or_canceled.includes(:project) }, foreign_key: :commit_id, class_name: 'Ci::Build', inverse_of: :pipeline
|
2017-04-06 12:31:38 +00:00
|
|
|
has_many :cancelable_statuses, -> { cancelable }, foreign_key: :commit_id, class_name: 'CommitStatus'
|
2020-07-22 00:09:26 +00:00
|
|
|
has_many :manual_actions, -> { latest.manual_actions.includes(:project) }, foreign_key: :commit_id, class_name: 'Ci::Build', inverse_of: :pipeline
|
|
|
|
has_many :scheduled_actions, -> { latest.scheduled_actions.includes(:project) }, foreign_key: :commit_id, class_name: 'Ci::Build', inverse_of: :pipeline
|
2017-04-06 12:31:38 +00:00
|
|
|
|
2017-06-02 10:16:11 +00:00
|
|
|
has_many :auto_canceled_pipelines, class_name: 'Ci::Pipeline', foreign_key: 'auto_canceled_by_id'
|
|
|
|
has_many :auto_canceled_jobs, class_name: 'CommitStatus', foreign_key: 'auto_canceled_by_id'
|
2019-10-16 09:07:51 +00:00
|
|
|
has_many :sourced_pipelines, class_name: 'Ci::Sources::Pipeline', foreign_key: :source_pipeline_id
|
2017-04-06 12:31:38 +00:00
|
|
|
|
2019-10-16 09:07:51 +00:00
|
|
|
has_one :source_pipeline, class_name: 'Ci::Sources::Pipeline', inverse_of: :pipeline
|
2020-02-27 18:09:21 +00:00
|
|
|
|
2019-02-20 21:29:48 +00:00
|
|
|
has_one :chat_data, class_name: 'Ci::PipelineChatData'
|
|
|
|
|
2019-10-16 09:07:51 +00:00
|
|
|
has_many :triggered_pipelines, through: :sourced_pipelines, source: :pipeline
|
2020-01-13 12:08:04 +00:00
|
|
|
has_many :child_pipelines, -> { merge(Ci::Sources::Pipeline.same_project) }, through: :sourced_pipelines, source: :pipeline
|
2019-10-16 09:07:51 +00:00
|
|
|
has_one :triggered_by_pipeline, through: :source_pipeline, source: :source_pipeline
|
2020-01-13 12:08:04 +00:00
|
|
|
has_one :parent_pipeline, -> { merge(Ci::Sources::Pipeline.same_project) }, through: :source_pipeline, source: :source_pipeline
|
2019-10-16 09:07:51 +00:00
|
|
|
has_one :source_job, through: :source_pipeline, source: :source_job
|
2020-02-08 06:08:50 +00:00
|
|
|
has_one :source_bridge, through: :source_pipeline, source: :source_bridge
|
2019-10-16 09:07:51 +00:00
|
|
|
|
2019-12-24 00:07:31 +00:00
|
|
|
has_one :pipeline_config, class_name: 'Ci::PipelineConfig', inverse_of: :pipeline
|
|
|
|
|
2020-05-06 15:09:42 +00:00
|
|
|
has_many :daily_build_group_report_results, class_name: 'Ci::DailyBuildGroupReportResult', foreign_key: :last_pipeline_id
|
2020-06-19 18:08:39 +00:00
|
|
|
has_many :latest_builds_report_results, through: :latest_builds, source: :report_results
|
2020-08-07 06:09:47 +00:00
|
|
|
has_many :pipeline_artifacts, class_name: 'Ci::PipelineArtifact', inverse_of: :pipeline, dependent: :destroy # rubocop:disable Cop/ActiveRecordDependent
|
2020-03-18 09:09:31 +00:00
|
|
|
|
2018-04-18 15:35:39 +00:00
|
|
|
accepts_nested_attributes_for :variables, reject_if: :persisted?
|
|
|
|
|
2017-09-18 12:29:43 +00:00
|
|
|
delegate :full_path, to: :project, prefix: true
|
2017-02-22 22:35:08 +00:00
|
|
|
|
2017-02-22 00:40:04 +00:00
|
|
|
validates :sha, presence: { unless: :importing? }
|
|
|
|
validates :ref, presence: { unless: :importing? }
|
2020-02-13 12:08:49 +00:00
|
|
|
validates :tag, inclusion: { in: [false], if: :merge_request? }
|
2019-08-09 09:40:45 +00:00
|
|
|
|
|
|
|
validates :external_pull_request, presence: { if: :external_pull_request_event? }
|
|
|
|
validates :external_pull_request, absence: { unless: :external_pull_request_event? }
|
|
|
|
validates :tag, inclusion: { in: [false], if: :external_pull_request_event? }
|
|
|
|
|
2017-02-22 00:40:04 +00:00
|
|
|
validates :status, presence: { unless: :importing? }
|
2016-08-30 08:09:41 +00:00
|
|
|
validate :valid_commit_sha, unless: :importing?
|
2018-12-15 09:06:56 +00:00
|
|
|
validates :source, exclusion: { in: %w(unknown), unless: :importing? }, on: :create
|
2018-05-11 13:07:23 +00:00
|
|
|
|
2016-10-19 12:03:31 +00:00
|
|
|
after_create :keep_around_commits, unless: :importing?
|
2016-04-11 14:55:40 +00:00
|
|
|
|
2021-05-14 12:10:58 +00:00
|
|
|
use_fast_destroy :job_artifacts
|
|
|
|
|
2020-08-24 21:10:17 +00:00
|
|
|
# We use `Enums::Ci::Pipeline.sources` here so that EE can more easily extend
|
2018-11-13 16:29:14 +00:00
|
|
|
# this `Hash` with new values.
|
2020-08-24 21:10:17 +00:00
|
|
|
enum_with_nil source: Enums::Ci::Pipeline.sources
|
2017-05-24 13:13:51 +00:00
|
|
|
|
2020-08-24 21:10:17 +00:00
|
|
|
enum_with_nil config_source: Enums::Ci::Pipeline.config_sources
|
2017-08-31 11:47:29 +00:00
|
|
|
|
2020-08-24 21:10:17 +00:00
|
|
|
# We use `Enums::Ci::Pipeline.failure_reasons` here so that EE can more easily
|
2018-11-13 16:29:14 +00:00
|
|
|
# extend this `Hash` with new values.
|
2020-08-24 21:10:17 +00:00
|
|
|
enum failure_reason: Enums::Ci::Pipeline.failure_reasons
|
2017-09-29 08:18:53 +00:00
|
|
|
|
2020-07-14 12:09:14 +00:00
|
|
|
enum locked: { unlocked: 0, artifacts_locked: 1 }
|
|
|
|
|
2016-08-11 18:54:02 +00:00
|
|
|
state_machine :status, initial: :created do
|
2016-08-12 11:57:58 +00:00
|
|
|
event :enqueue do
|
2020-05-08 12:09:37 +00:00
|
|
|
transition [:created, :manual, :waiting_for_resource, :preparing, :skipped, :scheduled] => :pending
|
2017-11-07 15:47:50 +00:00
|
|
|
transition [:success, :failed, :canceled] => :running
|
2020-05-08 12:09:37 +00:00
|
|
|
|
|
|
|
# this is needed to ensure tests to be covered
|
|
|
|
transition [:running] => :running
|
2016-08-12 09:36:51 +00:00
|
|
|
end
|
|
|
|
|
2019-12-24 12:08:01 +00:00
|
|
|
event :request_resource do
|
|
|
|
transition any - [:waiting_for_resource] => :waiting_for_resource
|
|
|
|
end
|
|
|
|
|
2019-02-27 02:13:06 +00:00
|
|
|
event :prepare do
|
|
|
|
transition any - [:preparing] => :preparing
|
|
|
|
end
|
|
|
|
|
2016-08-12 09:36:51 +00:00
|
|
|
event :run do
|
2016-10-20 07:33:44 +00:00
|
|
|
transition any - [:running] => :running
|
2016-08-12 09:36:51 +00:00
|
|
|
end
|
|
|
|
|
2016-08-11 18:54:02 +00:00
|
|
|
event :skip do
|
2016-10-20 07:33:44 +00:00
|
|
|
transition any - [:skipped] => :skipped
|
2016-08-11 18:54:02 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
event :drop do
|
2016-10-20 07:33:44 +00:00
|
|
|
transition any - [:failed] => :failed
|
2016-08-11 18:54:02 +00:00
|
|
|
end
|
|
|
|
|
2016-08-12 09:36:51 +00:00
|
|
|
event :succeed do
|
2016-10-20 07:33:44 +00:00
|
|
|
transition any - [:success] => :success
|
2016-08-12 09:36:51 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
event :cancel do
|
2016-10-20 07:33:44 +00:00
|
|
|
transition any - [:canceled] => :canceled
|
2016-08-11 18:54:02 +00:00
|
|
|
end
|
|
|
|
|
2017-03-03 11:51:23 +00:00
|
|
|
event :block do
|
2017-03-03 13:35:19 +00:00
|
|
|
transition any - [:manual] => :manual
|
2017-03-03 11:51:23 +00:00
|
|
|
end
|
|
|
|
|
2018-10-04 07:40:43 +00:00
|
|
|
event :delay do
|
2018-09-21 06:24:19 +00:00
|
|
|
transition any - [:scheduled] => :scheduled
|
|
|
|
end
|
|
|
|
|
2016-10-14 17:08:48 +00:00
|
|
|
# IMPORTANT
|
|
|
|
# Do not add any operations to this state_machine
|
|
|
|
# Create a separate worker for each new operation
|
|
|
|
|
2019-12-24 12:08:01 +00:00
|
|
|
before_transition [:created, :waiting_for_resource, :preparing, :pending] => :running do |pipeline|
|
2020-05-22 09:08:09 +00:00
|
|
|
pipeline.started_at = Time.current
|
2016-08-11 18:54:02 +00:00
|
|
|
end
|
|
|
|
|
2016-08-12 09:53:27 +00:00
|
|
|
before_transition any => [:success, :failed, :canceled] do |pipeline|
|
2020-05-22 09:08:09 +00:00
|
|
|
pipeline.finished_at = Time.current
|
2016-10-04 13:59:11 +00:00
|
|
|
pipeline.update_duration
|
|
|
|
end
|
|
|
|
|
2017-04-21 17:45:14 +00:00
|
|
|
before_transition any => [:manual] do |pipeline|
|
|
|
|
pipeline.update_duration
|
|
|
|
end
|
|
|
|
|
2017-04-06 15:47:37 +00:00
|
|
|
before_transition canceled: any - [:canceled] do |pipeline|
|
2017-04-06 14:04:45 +00:00
|
|
|
pipeline.auto_canceled_by = nil
|
|
|
|
end
|
|
|
|
|
2017-10-02 11:09:07 +00:00
|
|
|
before_transition any => :failed do |pipeline, transition|
|
|
|
|
transition.args.first.try do |reason|
|
|
|
|
pipeline.failure_reason = reason
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-12-24 12:08:01 +00:00
|
|
|
after_transition [:created, :waiting_for_resource, :preparing, :pending] => :running do |pipeline|
|
2017-04-20 06:44:01 +00:00
|
|
|
pipeline.run_after_commit { PipelineMetricsWorker.perform_async(pipeline.id) }
|
Improve performance of the cycle analytics page.
1. These changes bring down page load time for 100 issues from more than
a minute to about 1.5 seconds.
2. This entire commit is composed of these types of performance
enhancements:
- Cache relevant data in `IssueMetrics` wherever possible.
- Cache relevant data in `MergeRequestMetrics` wherever possible.
- Preload metrics
3. Given these improvements, we now only need to make 4 SQL calls:
- Load all issues
- Load all merge requests
- Load all metrics for the issues
- Load all metrics for the merge requests
4. A list of all the data points that are now being pre-calculated:
a. The first time an issue is mentioned in a commit
- In `GitPushService`, find all issues mentioned by the given commit
using `ReferenceExtractor`. Set the `first_mentioned_in_commit_at`
flag for each of them.
- There seems to be a (pre-existing) bug here - files (and
therefore commits) created using the Web CI don't have
cross-references created, and issues are not closed even when
the commit title is "Fixes #xx".
b. The first time a merge request is deployed to production
When a `Deployment` is created, find all merge requests that
were merged in before the deployment, and set the
`first_deployed_to_production_at` flag for each of them.
c. The start / end time for a merge request pipeline
Hook into the `Pipeline` state machine. When the `status` moves to
`running`, find the merge requests whose tip commit matches the
pipeline, and record the `latest_build_started_at` time for each
of them. When the `status` moves to `success`, record the
`latest_build_finished_at` time.
d. The merge requests that close an issue
- This was a big cause of the performance problems we were having
with Cycle Analytics. We need to use `ReferenceExtractor` to make
this calculation, which is slow when we have to run it on a large
number of merge requests.
- When a merge request is created, updated, or refreshed, find the
issues it closes, and create an instance of
`MergeRequestsClosingIssues`, which acts as a join model between
merge requests and issues.
- If a `MergeRequestsClosingIssues` instance links a merge request
and an issue, that issue closes that merge request.
5. The `Queries` module was changed into a class, so we can cache the
results of `issues` and `merge_requests_closing_issues` across
various cycle analytics stages.
6. The code added in this commit is untested. Tests will be added in the
next commit.
2016-09-15 08:59:36 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
after_transition any => [:success] do |pipeline|
|
2017-04-20 06:44:01 +00:00
|
|
|
pipeline.run_after_commit { PipelineMetricsWorker.perform_async(pipeline.id) }
|
Improve performance of the cycle analytics page.
1. These changes bring down page load time for 100 issues from more than
a minute to about 1.5 seconds.
2. This entire commit is composed of these types of performance
enhancements:
- Cache relevant data in `IssueMetrics` wherever possible.
- Cache relevant data in `MergeRequestMetrics` wherever possible.
- Preload metrics
3. Given these improvements, we now only need to make 4 SQL calls:
- Load all issues
- Load all merge requests
- Load all metrics for the issues
- Load all metrics for the merge requests
4. A list of all the data points that are now being pre-calculated:
a. The first time an issue is mentioned in a commit
- In `GitPushService`, find all issues mentioned by the given commit
using `ReferenceExtractor`. Set the `first_mentioned_in_commit_at`
flag for each of them.
- There seems to be a (pre-existing) bug here - files (and
therefore commits) created using the Web CI don't have
cross-references created, and issues are not closed even when
the commit title is "Fixes #xx".
b. The first time a merge request is deployed to production
When a `Deployment` is created, find all merge requests that
were merged in before the deployment, and set the
`first_deployed_to_production_at` flag for each of them.
c. The start / end time for a merge request pipeline
Hook into the `Pipeline` state machine. When the `status` moves to
`running`, find the merge requests whose tip commit matches the
pipeline, and record the `latest_build_started_at` time for each
of them. When the `status` moves to `success`, record the
`latest_build_finished_at` time.
d. The merge requests that close an issue
- This was a big cause of the performance problems we were having
with Cycle Analytics. We need to use `ReferenceExtractor` to make
this calculation, which is slow when we have to run it on a large
number of merge requests.
- When a merge request is created, updated, or refreshed, find the
issues it closes, and create an instance of
`MergeRequestsClosingIssues`, which acts as a join model between
merge requests and issues.
- If a `MergeRequestsClosingIssues` instance links a merge request
and an issue, that issue closes that merge request.
5. The `Queries` module was changed into a class, so we can cache the
results of `issues` and `merge_requests_closing_issues` across
various cycle analytics stages.
6. The code added in this commit is untested. Tests will be added in the
next commit.
2016-09-15 08:59:36 +00:00
|
|
|
end
|
|
|
|
|
2019-12-24 12:08:01 +00:00
|
|
|
after_transition [:created, :waiting_for_resource, :preparing, :pending, :running] => :success do |pipeline|
|
2021-07-13 15:08:38 +00:00
|
|
|
# We wait a little bit to ensure that all Ci::BuildFinishedWorkers finish first
|
2020-03-18 09:09:31 +00:00
|
|
|
# because this is where some metrics like code coverage is parsed and stored
|
|
|
|
# in CI build records which the daily build metrics worker relies on.
|
2020-05-06 15:09:42 +00:00
|
|
|
pipeline.run_after_commit { Ci::DailyBuildGroupReportResultsWorker.perform_in(10.minutes, pipeline.id) }
|
2016-08-11 18:54:02 +00:00
|
|
|
end
|
2016-08-12 10:03:30 +00:00
|
|
|
|
|
|
|
after_transition do |pipeline, transition|
|
2016-10-12 11:44:33 +00:00
|
|
|
next if transition.loopback?
|
|
|
|
|
|
|
|
pipeline.run_after_commit do
|
2017-04-20 06:44:01 +00:00
|
|
|
PipelineHooksWorker.perform_async(pipeline.id)
|
2021-02-26 18:11:10 +00:00
|
|
|
ExpirePipelineCacheWorker.perform_async(pipeline.id)
|
2016-10-12 11:44:33 +00:00
|
|
|
end
|
2016-08-12 10:03:30 +00:00
|
|
|
end
|
2016-09-14 11:42:16 +00:00
|
|
|
|
2019-05-27 12:21:36 +00:00
|
|
|
after_transition any => ::Ci::Pipeline.completed_statuses do |pipeline|
|
|
|
|
pipeline.run_after_commit do
|
2019-09-27 18:06:20 +00:00
|
|
|
pipeline.persistent_ref.delete
|
|
|
|
|
2019-05-27 12:21:36 +00:00
|
|
|
pipeline.all_merge_requests.each do |merge_request|
|
|
|
|
next unless merge_request.auto_merge_enabled?
|
|
|
|
|
|
|
|
AutoMergeProcessWorker.perform_async(merge_request.id)
|
|
|
|
end
|
2020-01-16 18:08:46 +00:00
|
|
|
|
|
|
|
if pipeline.auto_devops_source?
|
|
|
|
self.class.auto_devops_pipelines_completed_total.increment(status: pipeline.status)
|
|
|
|
end
|
2019-05-27 12:21:36 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-08-21 15:10:03 +00:00
|
|
|
after_transition any => ::Ci::Pipeline.completed_statuses do |pipeline|
|
|
|
|
pipeline.run_after_commit do
|
2020-12-29 09:10:42 +00:00
|
|
|
::Ci::PipelineArtifacts::CoverageReportWorker.perform_async(pipeline.id)
|
2021-01-22 18:09:10 +00:00
|
|
|
::Ci::PipelineArtifacts::CreateQualityReportWorker.perform_async(pipeline.id)
|
2020-08-21 15:10:03 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-02-08 06:08:50 +00:00
|
|
|
after_transition any => ::Ci::Pipeline.completed_statuses do |pipeline|
|
|
|
|
next unless pipeline.bridge_waiting?
|
|
|
|
|
|
|
|
pipeline.run_after_commit do
|
|
|
|
::Ci::PipelineBridgeStatusWorker.perform_async(pipeline.id)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-12-09 21:09:43 +00:00
|
|
|
after_transition any => any do |pipeline|
|
|
|
|
pipeline.run_after_commit do
|
|
|
|
# Passing the seq-id ensures this is idempotent
|
|
|
|
seq_id = ::Atlassian::JiraConnect::Client.generate_update_sequence_id
|
|
|
|
::JiraConnect::SyncBuildsWorker.perform_async(pipeline.id, seq_id)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-12-10 15:10:12 +00:00
|
|
|
after_transition any => ::Ci::Pipeline.completed_statuses do |pipeline|
|
|
|
|
pipeline.run_after_commit do
|
|
|
|
::Ci::TestFailureHistoryService.new(pipeline).async.perform_if_needed # rubocop: disable CodeReuse/ServiceClass
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-09-28 09:22:06 +00:00
|
|
|
after_transition any => [:success, :failed] do |pipeline|
|
2020-06-10 09:08:35 +00:00
|
|
|
ref_status = pipeline.ci_ref&.update_status_by!(pipeline)
|
|
|
|
|
2016-10-17 10:09:43 +00:00
|
|
|
pipeline.run_after_commit do
|
2020-06-10 09:08:35 +00:00
|
|
|
PipelineNotificationWorker.perform_async(pipeline.id, ref_status: ref_status)
|
2016-10-17 10:09:43 +00:00
|
|
|
end
|
2016-09-14 11:42:16 +00:00
|
|
|
end
|
2018-09-06 19:20:42 +00:00
|
|
|
|
|
|
|
after_transition any => [:failed] do |pipeline|
|
2021-04-15 15:09:11 +00:00
|
|
|
pipeline.run_after_commit do
|
|
|
|
::Gitlab::Ci::Pipeline::Metrics.pipeline_failure_reason_counter.increment(reason: pipeline.failure_reason)
|
2018-09-06 19:20:42 +00:00
|
|
|
|
2021-04-15 15:09:11 +00:00
|
|
|
AutoDevops::DisableWorker.perform_async(pipeline.id) if pipeline.auto_devops_source?
|
|
|
|
end
|
2018-09-06 19:20:42 +00:00
|
|
|
end
|
2016-08-11 18:54:02 +00:00
|
|
|
end
|
|
|
|
|
2017-11-10 19:57:11 +00:00
|
|
|
scope :internal, -> { where(source: internal_sources) }
|
2020-01-13 12:08:04 +00:00
|
|
|
scope :no_child, -> { where.not(source: :parent_pipeline) }
|
2020-09-07 12:08:27 +00:00
|
|
|
scope :ci_sources, -> { where(source: Enums::Ci::Pipeline.ci_sources.values) }
|
2020-12-08 03:09:37 +00:00
|
|
|
scope :ci_branch_sources, -> { where(source: Enums::Ci::Pipeline.ci_branch_sources.values) }
|
2020-11-11 15:08:46 +00:00
|
|
|
scope :ci_and_parent_sources, -> { where(source: Enums::Ci::Pipeline.ci_and_parent_sources.values) }
|
2018-12-04 15:14:24 +00:00
|
|
|
scope :for_user, -> (user) { where(user: user) }
|
2019-03-01 06:18:08 +00:00
|
|
|
scope :for_sha, -> (sha) { where(sha: sha) }
|
|
|
|
scope :for_source_sha, -> (source_sha) { where(source_sha: source_sha) }
|
|
|
|
scope :for_sha_or_source_sha, -> (sha) { for_sha(sha).or(for_source_sha(sha)) }
|
2019-10-18 11:11:44 +00:00
|
|
|
scope :for_ref, -> (ref) { where(ref: ref) }
|
2020-12-08 03:09:37 +00:00
|
|
|
scope :for_branch, -> (branch) { for_ref(branch).where(tag: false) }
|
2019-10-18 11:11:44 +00:00
|
|
|
scope :for_id, -> (id) { where(id: id) }
|
2020-06-15 18:08:43 +00:00
|
|
|
scope :for_iid, -> (iid) { where(iid: iid) }
|
2020-12-09 00:09:42 +00:00
|
|
|
scope :for_project, -> (project_id) { where(project_id: project_id) }
|
2019-08-19 14:29:53 +00:00
|
|
|
scope :created_after, -> (time) { where('ci_pipelines.created_at > ?', time) }
|
2020-07-14 12:09:14 +00:00
|
|
|
scope :created_before_id, -> (id) { where('ci_pipelines.id < ?', id) }
|
|
|
|
scope :before_pipeline, -> (pipeline) { created_before_id(pipeline.id).outside_pipeline_family(pipeline) }
|
2021-03-26 21:09:22 +00:00
|
|
|
scope :eager_load_project, -> { eager_load(project: [:route, { namespace: :route }]) }
|
2021-08-13 21:09:54 +00:00
|
|
|
scope :with_pipeline_source, -> (source) { where(source: source)}
|
2020-07-14 12:09:14 +00:00
|
|
|
|
|
|
|
scope :outside_pipeline_family, ->(pipeline) do
|
|
|
|
where.not(id: pipeline.same_family_pipeline_ids)
|
|
|
|
end
|
2019-01-02 06:39:45 +00:00
|
|
|
|
2019-04-16 11:06:52 +00:00
|
|
|
scope :with_reports, -> (reports_scope) do
|
|
|
|
where('EXISTS (?)', ::Ci::Build.latest.with_reports(reports_scope).where('ci_pipelines.id=ci_builds.commit_id').select(1))
|
|
|
|
end
|
|
|
|
|
2019-09-11 22:09:42 +00:00
|
|
|
scope :with_only_interruptible_builds, -> do
|
2019-09-05 14:50:39 +00:00
|
|
|
where('NOT EXISTS (?)',
|
|
|
|
Ci::Build.where('ci_builds.commit_id = ci_pipelines.id')
|
|
|
|
.with_status(:running, :success, :failed)
|
|
|
|
.not_interruptible
|
|
|
|
)
|
|
|
|
end
|
|
|
|
|
2020-07-15 21:09:26 +00:00
|
|
|
# Returns the pipelines that associated with the given merge request.
|
|
|
|
# In general, please use `Ci::PipelinesForMergeRequestFinder` instead,
|
|
|
|
# for checking permission of the actor.
|
|
|
|
scope :triggered_by_merge_request, -> (merge_request) do
|
2020-12-08 03:09:37 +00:00
|
|
|
where(source: :merge_request_event,
|
|
|
|
merge_request: merge_request,
|
|
|
|
project: [merge_request.source_project, merge_request.target_project])
|
2020-07-15 21:09:26 +00:00
|
|
|
end
|
|
|
|
|
2017-11-10 19:57:11 +00:00
|
|
|
# Returns the pipelines in descending order (= newest first), optionally
|
|
|
|
# limited to a number of references.
|
|
|
|
#
|
|
|
|
# ref - The name (or names) of the branch(es)/tag(s) to limit the list of
|
|
|
|
# pipelines to.
|
2019-07-23 19:29:12 +00:00
|
|
|
# sha - The commit SHA (or mutliple SHAs) to limit the list of pipelines to.
|
2018-11-05 22:52:15 +00:00
|
|
|
# limit - This limits a backlog search, default to 100.
|
2019-07-17 13:33:52 +00:00
|
|
|
def self.newest_first(ref: nil, sha: nil, limit: 100)
|
2017-11-10 19:57:11 +00:00
|
|
|
relation = order(id: :desc)
|
2018-11-05 22:52:15 +00:00
|
|
|
relation = relation.where(ref: ref) if ref
|
2019-07-17 13:33:52 +00:00
|
|
|
relation = relation.where(sha: sha) if sha
|
2017-11-10 19:57:11 +00:00
|
|
|
|
2018-11-05 22:52:15 +00:00
|
|
|
if limit
|
|
|
|
ids = relation.limit(limit).select(:id)
|
|
|
|
relation = relation.where(id: ids)
|
|
|
|
end
|
|
|
|
|
|
|
|
relation
|
2016-11-21 14:19:16 +00:00
|
|
|
end
|
2016-11-07 15:44:11 +00:00
|
|
|
|
2016-12-14 13:00:06 +00:00
|
|
|
def self.latest_status(ref = nil)
|
2018-11-05 22:52:15 +00:00
|
|
|
newest_first(ref: ref).pluck(:status).first
|
2016-12-14 13:00:06 +00:00
|
|
|
end
|
|
|
|
|
2019-07-23 19:29:12 +00:00
|
|
|
def self.latest_successful_for_ref(ref)
|
2018-11-05 22:52:15 +00:00
|
|
|
newest_first(ref: ref).success.take
|
2016-07-19 12:59:38 +00:00
|
|
|
end
|
|
|
|
|
2019-07-17 13:33:52 +00:00
|
|
|
def self.latest_successful_for_sha(sha)
|
|
|
|
newest_first(sha: sha).success.take
|
|
|
|
end
|
|
|
|
|
2017-03-13 16:00:07 +00:00
|
|
|
def self.latest_successful_for_refs(refs)
|
2021-08-16 09:09:05 +00:00
|
|
|
return Ci::Pipeline.none if refs.empty?
|
2017-11-10 19:57:11 +00:00
|
|
|
|
2021-08-16 09:09:05 +00:00
|
|
|
refs_values = refs.map { |ref| "(#{connection.quote(ref)})" }.join(",")
|
|
|
|
join_query = success.where("refs_values.ref = ci_pipelines.ref").order(id: :desc).limit(1)
|
|
|
|
|
|
|
|
Ci::Pipeline
|
|
|
|
.from("(VALUES #{refs_values}) refs_values (ref)")
|
|
|
|
.joins("INNER JOIN LATERAL (#{join_query.to_sql}) #{Ci::Pipeline.table_name} ON TRUE")
|
|
|
|
.index_by(&:ref)
|
2017-03-13 16:00:07 +00:00
|
|
|
end
|
|
|
|
|
2020-11-13 21:09:31 +00:00
|
|
|
def self.latest_running_for_ref(ref)
|
|
|
|
newest_first(ref: ref).running.take
|
|
|
|
end
|
|
|
|
|
|
|
|
def self.latest_failed_for_ref(ref)
|
|
|
|
newest_first(ref: ref).failed.take
|
|
|
|
end
|
|
|
|
|
2021-07-27 06:09:01 +00:00
|
|
|
def self.jobs_count_in_alive_pipelines
|
|
|
|
created_after(24.hours.ago).alive.joins(:builds).count
|
|
|
|
end
|
|
|
|
|
2019-09-30 15:08:09 +00:00
|
|
|
# Returns a Hash containing the latest pipeline for every given
|
2017-11-10 19:57:11 +00:00
|
|
|
# commit.
|
|
|
|
#
|
2019-09-30 15:08:09 +00:00
|
|
|
# The keys of this Hash are the commit SHAs, the values the pipelines.
|
2017-11-10 19:57:11 +00:00
|
|
|
#
|
2019-09-30 15:08:09 +00:00
|
|
|
# commits - The list of commit SHAs to get the pipelines for.
|
2017-11-10 19:57:11 +00:00
|
|
|
# ref - The ref to scope the data to (e.g. "master"). If the ref is not
|
2019-09-30 15:08:09 +00:00
|
|
|
# given we simply get the latest pipelines for the commits, regardless
|
|
|
|
# of what refs the pipelines belong to.
|
2020-06-26 18:09:03 +00:00
|
|
|
def self.latest_pipeline_per_commit(commits, ref = nil)
|
2021-04-09 15:09:10 +00:00
|
|
|
sql = select('DISTINCT ON (sha) *')
|
|
|
|
.where(sha: commits)
|
|
|
|
.order(:sha, id: :desc)
|
2017-11-10 19:57:11 +00:00
|
|
|
|
2021-04-09 15:09:10 +00:00
|
|
|
sql = sql.where(ref: ref) if ref
|
2017-11-10 19:57:11 +00:00
|
|
|
|
2021-04-09 15:09:10 +00:00
|
|
|
sql.each_with_object({}) do |pipeline, hash|
|
2020-06-26 18:09:03 +00:00
|
|
|
hash[pipeline.sha] = pipeline
|
2017-11-10 19:57:11 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-11-05 23:56:52 +00:00
|
|
|
def self.latest_successful_ids_per_project
|
|
|
|
success.group(:project_id).select('max(id) as id')
|
|
|
|
end
|
|
|
|
|
2020-06-25 15:08:37 +00:00
|
|
|
def self.last_finished_for_ref_id(ci_ref_id)
|
|
|
|
where(ci_ref_id: ci_ref_id).ci_sources.finished.order(id: :desc).select(:id).take
|
|
|
|
end
|
|
|
|
|
2015-08-26 01:42:46 +00:00
|
|
|
def self.truncate_sha(sha)
|
|
|
|
sha[0...8]
|
|
|
|
end
|
|
|
|
|
2016-08-15 10:54:38 +00:00
|
|
|
def self.total_duration
|
2016-08-15 10:50:02 +00:00
|
|
|
where.not(duration: nil).sum(:duration)
|
2016-08-10 14:45:30 +00:00
|
|
|
end
|
|
|
|
|
2017-06-19 17:56:27 +00:00
|
|
|
def self.internal_sources
|
|
|
|
sources.reject { |source| source == "external" }.values
|
|
|
|
end
|
|
|
|
|
2019-07-31 15:36:57 +00:00
|
|
|
def self.bridgeable_statuses
|
2019-12-24 12:08:01 +00:00
|
|
|
::Ci::Pipeline::AVAILABLE_STATUSES - %w[created waiting_for_resource preparing pending]
|
2019-07-31 15:36:57 +00:00
|
|
|
end
|
|
|
|
|
2020-01-16 18:08:46 +00:00
|
|
|
def self.auto_devops_pipelines_completed_total
|
|
|
|
@auto_devops_pipelines_completed_total ||= Gitlab::Metrics.counter(:auto_devops_pipelines_completed_total, 'Number of completed auto devops pipelines')
|
|
|
|
end
|
|
|
|
|
2021-03-31 15:10:27 +00:00
|
|
|
def uses_needs?
|
|
|
|
builds.where(scheduling_type: :dag).any?
|
|
|
|
end
|
|
|
|
|
2016-12-05 13:17:42 +00:00
|
|
|
def stages_count
|
|
|
|
statuses.select(:stage).distinct.count
|
2016-11-10 14:32:23 +00:00
|
|
|
end
|
|
|
|
|
2017-12-18 09:13:46 +00:00
|
|
|
def total_size
|
|
|
|
statuses.count(:id)
|
|
|
|
end
|
|
|
|
|
2017-06-01 09:55:18 +00:00
|
|
|
def stages_names
|
2017-06-21 13:48:12 +00:00
|
|
|
statuses.order(:stage_idx).distinct
|
|
|
|
.pluck(:stage, :stage_idx).map(&:first)
|
2016-12-06 13:49:37 +00:00
|
|
|
end
|
|
|
|
|
2017-06-01 09:55:18 +00:00
|
|
|
def legacy_stage(name)
|
2017-06-01 10:00:37 +00:00
|
|
|
stage = Ci::LegacyStage.new(self, name: name)
|
2020-08-12 06:09:53 +00:00
|
|
|
stage unless stage.statuses_count == 0
|
2017-06-01 09:55:18 +00:00
|
|
|
end
|
|
|
|
|
2018-10-08 15:55:13 +00:00
|
|
|
def ref_exists?
|
2018-10-22 09:37:52 +00:00
|
|
|
project.repository.ref_exists?(git_ref)
|
2018-10-22 11:33:28 +00:00
|
|
|
rescue Gitlab::Git::Repository::NoRepository
|
|
|
|
false
|
2018-10-08 15:55:13 +00:00
|
|
|
end
|
|
|
|
|
2019-10-01 12:05:59 +00:00
|
|
|
def legacy_stages_using_composite_status
|
2019-12-24 15:07:44 +00:00
|
|
|
stages = latest_statuses_ordered_by_stage.group_by(&:stage)
|
2019-10-01 12:05:59 +00:00
|
|
|
|
|
|
|
stages.map do |stage_name, jobs|
|
|
|
|
composite_status = Gitlab::Ci::Status::Composite
|
|
|
|
.new(jobs)
|
|
|
|
|
|
|
|
Ci::LegacyStage.new(self,
|
|
|
|
name: stage_name,
|
|
|
|
status: composite_status.status,
|
|
|
|
warnings: composite_status.warnings?)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-07-10 12:09:15 +00:00
|
|
|
def triggered_pipelines_with_preloads
|
|
|
|
triggered_pipelines.preload(:source_job)
|
|
|
|
end
|
|
|
|
|
2020-08-13 15:10:03 +00:00
|
|
|
# TODO: Remove usage of this method in templates
|
2019-10-01 12:05:59 +00:00
|
|
|
def legacy_stages
|
2020-08-19 12:10:17 +00:00
|
|
|
legacy_stages_using_composite_status
|
2019-10-01 12:05:59 +00:00
|
|
|
end
|
|
|
|
|
2015-08-26 01:42:46 +00:00
|
|
|
def valid_commit_sha
|
2015-12-11 16:57:04 +00:00
|
|
|
if self.sha == Gitlab::Git::BLANK_SHA
|
2015-08-26 01:42:46 +00:00
|
|
|
self.errors.add(:sha, " cant be 00000000 (branch removal)")
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def git_author_name
|
2018-05-07 15:13:03 +00:00
|
|
|
strong_memoize(:git_author_name) do
|
|
|
|
commit.try(:author_name)
|
|
|
|
end
|
2015-08-26 01:42:46 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
def git_author_email
|
2018-05-07 15:13:03 +00:00
|
|
|
strong_memoize(:git_author_email) do
|
|
|
|
commit.try(:author_email)
|
|
|
|
end
|
2015-08-26 01:42:46 +00:00
|
|
|
end
|
|
|
|
|
2021-03-23 15:09:28 +00:00
|
|
|
def git_author_full_text
|
|
|
|
strong_memoize(:git_author_full_text) do
|
|
|
|
commit.try(:author_full_text)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2015-08-26 01:42:46 +00:00
|
|
|
def git_commit_message
|
2018-05-07 15:13:03 +00:00
|
|
|
strong_memoize(:git_commit_message) do
|
|
|
|
commit.try(:message)
|
|
|
|
end
|
2015-08-26 01:42:46 +00:00
|
|
|
end
|
|
|
|
|
2016-07-11 07:11:20 +00:00
|
|
|
def git_commit_title
|
2018-05-07 15:13:03 +00:00
|
|
|
strong_memoize(:git_commit_title) do
|
|
|
|
commit.try(:title)
|
|
|
|
end
|
2016-07-11 07:11:20 +00:00
|
|
|
end
|
|
|
|
|
2018-05-01 15:09:33 +00:00
|
|
|
def git_commit_full_title
|
2018-05-07 15:13:03 +00:00
|
|
|
strong_memoize(:git_commit_full_title) do
|
|
|
|
commit.try(:full_title)
|
|
|
|
end
|
2018-05-01 15:09:33 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
def git_commit_description
|
2018-05-07 15:13:03 +00:00
|
|
|
strong_memoize(:git_commit_description) do
|
|
|
|
commit.try(:description)
|
|
|
|
end
|
2016-07-11 07:11:20 +00:00
|
|
|
end
|
|
|
|
|
2020-09-01 18:10:48 +00:00
|
|
|
def git_commit_timestamp
|
|
|
|
strong_memoize(:git_commit_timestamp) do
|
|
|
|
commit.try(:timestamp)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-11-20 18:06:04 +00:00
|
|
|
def before_sha
|
|
|
|
super || Gitlab::Git::BLANK_SHA
|
|
|
|
end
|
|
|
|
|
2015-08-26 01:42:46 +00:00
|
|
|
def short_sha
|
2016-06-02 14:19:18 +00:00
|
|
|
Ci::Pipeline.truncate_sha(sha)
|
2015-08-26 01:42:46 +00:00
|
|
|
end
|
|
|
|
|
2017-12-05 13:15:30 +00:00
|
|
|
# NOTE: This is loaded lazily and will never be nil, even if the commit
|
|
|
|
# cannot be found.
|
|
|
|
#
|
|
|
|
# Use constructs like: `pipeline.commit.present?`
|
2016-06-21 12:43:37 +00:00
|
|
|
def commit
|
2017-12-05 13:15:30 +00:00
|
|
|
@commit ||= Commit.lazy(project, sha)
|
2015-08-26 01:42:46 +00:00
|
|
|
end
|
|
|
|
|
2016-12-15 21:06:39 +00:00
|
|
|
def stuck?
|
2017-04-06 12:31:38 +00:00
|
|
|
pending_builds.any?(&:stuck?)
|
2016-07-16 16:39:58 +00:00
|
|
|
end
|
|
|
|
|
2016-03-31 17:51:28 +00:00
|
|
|
def retryable?
|
2017-04-06 12:31:38 +00:00
|
|
|
retryable_builds.any?
|
2016-03-31 17:51:28 +00:00
|
|
|
end
|
|
|
|
|
2016-05-31 13:26:00 +00:00
|
|
|
def cancelable?
|
2017-04-06 12:31:38 +00:00
|
|
|
cancelable_statuses.any?
|
2016-05-31 13:26:00 +00:00
|
|
|
end
|
|
|
|
|
2017-04-05 19:10:52 +00:00
|
|
|
def auto_canceled?
|
|
|
|
canceled? && auto_canceled_by_id?
|
|
|
|
end
|
|
|
|
|
2021-06-24 15:07:28 +00:00
|
|
|
def cancel_running(retries: 1)
|
2021-04-06 09:09:03 +00:00
|
|
|
commit_status_relations = [:project, :pipeline]
|
|
|
|
ci_build_relations = [:deployment, :taggings]
|
|
|
|
|
2021-06-24 15:07:28 +00:00
|
|
|
retry_lock(cancelable_statuses, retries, name: 'ci_pipeline_cancel_running') do |cancelables|
|
2021-04-06 09:09:03 +00:00
|
|
|
cancelables.find_in_batches do |batch|
|
|
|
|
ActiveRecord::Associations::Preloader.new.preload(batch, commit_status_relations)
|
|
|
|
ActiveRecord::Associations::Preloader.new.preload(batch.select { |job| job.is_a?(Ci::Build) }, ci_build_relations)
|
|
|
|
|
|
|
|
batch.each do |job|
|
|
|
|
yield(job) if block_given?
|
|
|
|
job.cancel
|
|
|
|
end
|
2016-11-23 11:43:56 +00:00
|
|
|
end
|
2017-04-07 06:47:15 +00:00
|
|
|
end
|
2016-05-09 23:26:13 +00:00
|
|
|
end
|
|
|
|
|
2021-06-24 15:07:28 +00:00
|
|
|
def auto_cancel_running(pipeline, retries: 1)
|
2017-04-06 13:32:56 +00:00
|
|
|
update(auto_canceled_by: pipeline)
|
|
|
|
|
2019-09-02 08:44:52 +00:00
|
|
|
cancel_running(retries: retries) do |job|
|
2017-04-06 13:32:56 +00:00
|
|
|
job.auto_canceled_by = pipeline
|
2017-04-06 12:31:38 +00:00
|
|
|
end
|
2016-05-09 23:26:13 +00:00
|
|
|
end
|
|
|
|
|
2018-08-27 15:31:01 +00:00
|
|
|
# rubocop: disable CodeReuse/ServiceClass
|
2017-02-14 11:20:02 +00:00
|
|
|
def retry_failed(current_user)
|
2017-02-22 22:54:59 +00:00
|
|
|
Ci::RetryPipelineService.new(project, current_user)
|
|
|
|
.execute(self)
|
2016-05-09 23:26:13 +00:00
|
|
|
end
|
2018-08-27 15:31:01 +00:00
|
|
|
# rubocop: enable CodeReuse/ServiceClass
|
2016-05-09 23:26:13 +00:00
|
|
|
|
2020-06-23 18:09:28 +00:00
|
|
|
def lazy_ref_commit
|
|
|
|
BatchLoader.for(ref).batch do |refs, loader|
|
|
|
|
next unless project.repository_exists?
|
|
|
|
|
|
|
|
project.repository.list_commits_by_ref_name(refs).then do |commits|
|
2020-06-30 12:08:57 +00:00
|
|
|
commits.each { |key, commit| loader.call(key, commits[key]) }
|
2020-06-23 18:09:28 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-04-13 11:01:08 +00:00
|
|
|
def latest?
|
2019-03-17 06:23:11 +00:00
|
|
|
return false unless git_ref && commit.present?
|
2020-06-23 18:09:28 +00:00
|
|
|
return false if lazy_ref_commit.nil?
|
|
|
|
|
|
|
|
lazy_ref_commit.id == commit.id
|
2016-04-13 11:01:08 +00:00
|
|
|
end
|
|
|
|
|
2015-10-06 10:01:16 +00:00
|
|
|
def retried
|
2020-09-28 09:09:35 +00:00
|
|
|
@retried ||= (statuses.order(id: :desc) - latest_statuses)
|
2015-08-26 01:42:46 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
def coverage
|
2020-09-28 09:09:35 +00:00
|
|
|
coverage_array = latest_statuses.map(&:coverage).compact
|
2015-12-04 11:55:23 +00:00
|
|
|
if coverage_array.size >= 1
|
|
|
|
'%.2f' % (coverage_array.reduce(:+) / coverage_array.size)
|
2015-08-26 01:42:46 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2021-06-11 18:10:13 +00:00
|
|
|
def update_builds_coverage
|
|
|
|
builds.with_coverage_regex.without_coverage.each(&:update_coverage)
|
|
|
|
end
|
|
|
|
|
2020-07-17 06:09:11 +00:00
|
|
|
def batch_lookup_report_artifact_for_file_type(file_type)
|
|
|
|
latest_report_artifacts
|
|
|
|
.values_at(*::Ci::JobArtifact.associated_file_types_for(file_type.to_s))
|
|
|
|
.flatten
|
|
|
|
.compact
|
|
|
|
.last
|
|
|
|
end
|
|
|
|
|
|
|
|
# This batch loads the latest reports for each CI job artifact
|
|
|
|
# type (e.g. sast, dast, etc.) in a single SQL query to eliminate
|
|
|
|
# the need to do N different `job_artifacts.where(file_type:
|
|
|
|
# X).last` calls.
|
|
|
|
#
|
|
|
|
# Return a hash of file type => array of 1 job artifact
|
|
|
|
def latest_report_artifacts
|
|
|
|
::Gitlab::SafeRequestStore.fetch("pipeline:#{self.id}:latest_report_artifacts") do
|
|
|
|
::Ci::JobArtifact.where(
|
|
|
|
id: job_artifacts.with_reports
|
|
|
|
.select('max(ci_job_artifacts.id) as id')
|
|
|
|
.group(:file_type)
|
|
|
|
)
|
|
|
|
.preload(:job)
|
|
|
|
.group_by(&:file_type)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2017-09-01 10:58:22 +00:00
|
|
|
def has_kubernetes_active?
|
2021-04-09 09:09:10 +00:00
|
|
|
strong_memoize(:has_kubernetes_active) do
|
|
|
|
project.deployment_platform&.active?
|
|
|
|
end
|
2017-08-26 10:45:36 +00:00
|
|
|
end
|
|
|
|
|
2020-06-26 00:09:13 +00:00
|
|
|
def freeze_period?
|
|
|
|
Ci::FreezePeriodStatus.new(project: project).execute
|
|
|
|
end
|
|
|
|
|
2016-07-14 14:58:05 +00:00
|
|
|
def has_warnings?
|
2020-08-12 06:09:53 +00:00
|
|
|
number_of_warnings > 0
|
2018-05-07 16:22:07 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
def number_of_warnings
|
|
|
|
BatchLoader.for(id).batch(default_value: 0) do |pipeline_ids, loader|
|
2021-01-27 09:09:01 +00:00
|
|
|
::CommitStatus.where(commit_id: pipeline_ids)
|
2018-05-07 16:22:07 +00:00
|
|
|
.latest
|
|
|
|
.failed_but_allowed
|
|
|
|
.group(:commit_id)
|
|
|
|
.count
|
|
|
|
.each { |id, amount| loader.call(id, amount) }
|
|
|
|
end
|
2016-07-12 17:05:48 +00:00
|
|
|
end
|
|
|
|
|
2020-01-17 15:08:37 +00:00
|
|
|
def needs_processing?
|
|
|
|
statuses
|
|
|
|
.where(processed: [false, nil])
|
|
|
|
.latest
|
|
|
|
.exists?
|
|
|
|
end
|
|
|
|
|
2016-12-21 13:26:47 +00:00
|
|
|
def has_yaml_errors?
|
|
|
|
yaml_errors.present?
|
|
|
|
end
|
|
|
|
|
2020-06-29 12:09:20 +00:00
|
|
|
def add_error_message(content)
|
2020-07-13 12:09:18 +00:00
|
|
|
add_message(:error, content)
|
|
|
|
end
|
|
|
|
|
|
|
|
def add_warning_message(content)
|
|
|
|
add_message(:warning, content)
|
|
|
|
end
|
|
|
|
|
|
|
|
# We can't use `messages.error` scope here because messages should also be
|
|
|
|
# read when the pipeline is not persisted. Using the scope will return no
|
|
|
|
# results as it would query persisted data.
|
|
|
|
def error_messages
|
|
|
|
messages.select(&:error?)
|
|
|
|
end
|
2020-06-29 12:09:20 +00:00
|
|
|
|
2020-09-03 06:08:22 +00:00
|
|
|
def warning_messages(limit: nil)
|
|
|
|
messages.select(&:warning?).tap do |warnings|
|
|
|
|
break warnings.take(limit) if limit
|
|
|
|
end
|
2020-06-29 12:09:20 +00:00
|
|
|
end
|
|
|
|
|
2016-06-23 10:29:11 +00:00
|
|
|
# Manually set the notes for a Ci::Pipeline
|
|
|
|
# There is no ActiveRecord relation between Ci::Pipeline and notes
|
|
|
|
# as they are related to a commit sha. This method helps importing
|
2020-02-26 18:09:24 +00:00
|
|
|
# them using the +Gitlab::ImportExport::Project::RelationFactory+ class.
|
2016-06-23 10:29:11 +00:00
|
|
|
def notes=(notes)
|
|
|
|
notes.each do |note|
|
|
|
|
note[:id] = nil
|
|
|
|
note[:commit_id] = sha
|
|
|
|
note[:noteable_id] = self['id']
|
|
|
|
note.save!
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-06-13 08:55:54 +00:00
|
|
|
def notes
|
2017-11-07 16:11:37 +00:00
|
|
|
project.notes.for_commit_id(sha)
|
2016-06-13 08:55:54 +00:00
|
|
|
end
|
|
|
|
|
2020-01-17 15:08:37 +00:00
|
|
|
def set_status(new_status)
|
2021-03-02 15:10:57 +00:00
|
|
|
retry_optimistic_lock(self, name: 'ci_pipeline_set_status') do
|
2019-10-01 12:05:59 +00:00
|
|
|
case new_status
|
2018-06-04 09:29:39 +00:00
|
|
|
when 'created' then nil
|
2019-12-24 12:08:01 +00:00
|
|
|
when 'waiting_for_resource' then request_resource
|
2019-02-27 02:13:06 +00:00
|
|
|
when 'preparing' then prepare
|
2016-09-19 12:13:08 +00:00
|
|
|
when 'pending' then enqueue
|
|
|
|
when 'running' then run
|
|
|
|
when 'success' then succeed
|
|
|
|
when 'failed' then drop
|
|
|
|
when 'canceled' then cancel
|
|
|
|
when 'skipped' then skip
|
2017-03-03 13:35:19 +00:00
|
|
|
when 'manual' then block
|
2018-10-04 07:40:43 +00:00
|
|
|
when 'scheduled' then delay
|
2018-06-04 09:29:39 +00:00
|
|
|
else
|
2020-06-22 15:09:27 +00:00
|
|
|
raise Ci::HasStatus::UnknownStatusError,
|
2019-10-01 12:05:59 +00:00
|
|
|
"Unknown status `#{new_status}`"
|
2016-09-19 12:13:08 +00:00
|
|
|
end
|
2016-08-12 09:36:51 +00:00
|
|
|
end
|
2016-08-11 13:22:35 +00:00
|
|
|
end
|
|
|
|
|
2018-03-21 08:33:14 +00:00
|
|
|
def protected_ref?
|
2018-11-10 13:34:53 +00:00
|
|
|
strong_memoize(:protected_ref) { project.protected_for?(git_ref) }
|
2018-03-21 08:33:14 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
def legacy_trigger
|
2018-03-21 08:53:26 +00:00
|
|
|
strong_memoize(:legacy_trigger) { trigger_requests.first }
|
2018-03-21 08:33:14 +00:00
|
|
|
end
|
|
|
|
|
2018-05-18 09:28:32 +00:00
|
|
|
def persisted_variables
|
|
|
|
Gitlab::Ci::Variables::Collection.new.tap do |variables|
|
2018-05-20 12:18:50 +00:00
|
|
|
break variables unless persisted?
|
|
|
|
|
|
|
|
variables.append(key: 'CI_PIPELINE_ID', value: id.to_s)
|
|
|
|
variables.append(key: 'CI_PIPELINE_URL', value: Gitlab::Routing.url_helpers.project_pipeline_url(project, self))
|
2018-05-18 09:28:32 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-07-20 11:17:21 +00:00
|
|
|
def predefined_variables
|
2018-12-06 12:52:06 +00:00
|
|
|
Gitlab::Ci::Variables::Collection.new.tap do |variables|
|
|
|
|
variables.append(key: 'CI_PIPELINE_IID', value: iid.to_s)
|
|
|
|
variables.append(key: 'CI_PIPELINE_SOURCE', value: source.to_s)
|
2021-03-10 00:09:13 +00:00
|
|
|
variables.append(key: 'CI_PIPELINE_CREATED_AT', value: created_at&.iso8601)
|
2019-11-20 18:06:04 +00:00
|
|
|
|
|
|
|
variables.concat(predefined_commit_variables)
|
2018-12-06 12:52:06 +00:00
|
|
|
|
2020-02-13 12:08:49 +00:00
|
|
|
if merge_request?
|
2019-08-28 07:51:26 +00:00
|
|
|
variables.append(key: 'CI_MERGE_REQUEST_EVENT_TYPE', value: merge_request_event_type.to_s)
|
2019-02-20 06:37:49 +00:00
|
|
|
variables.append(key: 'CI_MERGE_REQUEST_SOURCE_BRANCH_SHA', value: source_sha.to_s)
|
|
|
|
variables.append(key: 'CI_MERGE_REQUEST_TARGET_BRANCH_SHA', value: target_sha.to_s)
|
2020-11-27 15:09:34 +00:00
|
|
|
|
2020-12-02 18:09:35 +00:00
|
|
|
diff = self.merge_request_diff
|
|
|
|
if diff.present?
|
|
|
|
variables.append(key: 'CI_MERGE_REQUEST_DIFF_ID', value: diff.id.to_s)
|
|
|
|
variables.append(key: 'CI_MERGE_REQUEST_DIFF_BASE_SHA', value: diff.base_commit_sha)
|
2020-11-27 15:09:34 +00:00
|
|
|
end
|
|
|
|
|
2018-12-06 12:52:06 +00:00
|
|
|
variables.concat(merge_request.predefined_variables)
|
|
|
|
end
|
2019-08-09 09:40:45 +00:00
|
|
|
|
2021-02-02 03:09:10 +00:00
|
|
|
if open_merge_requests_refs.any?
|
2020-12-16 12:09:53 +00:00
|
|
|
variables.append(key: 'CI_OPEN_MERGE_REQUESTS', value: open_merge_requests_refs.join(','))
|
|
|
|
end
|
|
|
|
|
2020-05-08 03:09:54 +00:00
|
|
|
variables.append(key: 'CI_KUBERNETES_ACTIVE', value: 'true') if has_kubernetes_active?
|
2020-06-26 00:09:13 +00:00
|
|
|
variables.append(key: 'CI_DEPLOY_FREEZE', value: 'true') if freeze_period?
|
2020-05-08 03:09:54 +00:00
|
|
|
|
2019-08-09 09:40:45 +00:00
|
|
|
if external_pull_request_event? && external_pull_request
|
|
|
|
variables.concat(external_pull_request.predefined_variables)
|
|
|
|
end
|
2018-12-06 12:52:06 +00:00
|
|
|
end
|
2016-07-20 11:17:21 +00:00
|
|
|
end
|
|
|
|
|
2019-11-20 18:06:04 +00:00
|
|
|
def predefined_commit_variables
|
|
|
|
Gitlab::Ci::Variables::Collection.new.tap do |variables|
|
|
|
|
variables.append(key: 'CI_COMMIT_SHA', value: sha)
|
|
|
|
variables.append(key: 'CI_COMMIT_SHORT_SHA', value: short_sha)
|
|
|
|
variables.append(key: 'CI_COMMIT_BEFORE_SHA', value: before_sha)
|
|
|
|
variables.append(key: 'CI_COMMIT_REF_NAME', value: source_ref)
|
|
|
|
variables.append(key: 'CI_COMMIT_REF_SLUG', value: source_ref_slug)
|
2019-12-16 12:07:43 +00:00
|
|
|
variables.append(key: 'CI_COMMIT_BRANCH', value: ref) if branch?
|
2019-11-20 18:06:04 +00:00
|
|
|
variables.append(key: 'CI_COMMIT_TAG', value: ref) if tag?
|
|
|
|
variables.append(key: 'CI_COMMIT_MESSAGE', value: git_commit_message.to_s)
|
|
|
|
variables.append(key: 'CI_COMMIT_TITLE', value: git_commit_full_title.to_s)
|
|
|
|
variables.append(key: 'CI_COMMIT_DESCRIPTION', value: git_commit_description.to_s)
|
|
|
|
variables.append(key: 'CI_COMMIT_REF_PROTECTED', value: (!!protected_ref?).to_s)
|
2020-09-01 18:10:48 +00:00
|
|
|
variables.append(key: 'CI_COMMIT_TIMESTAMP', value: git_commit_timestamp.to_s)
|
2021-03-23 15:09:28 +00:00
|
|
|
variables.append(key: 'CI_COMMIT_AUTHOR', value: git_author_full_text.to_s)
|
2019-11-20 18:06:04 +00:00
|
|
|
|
|
|
|
# legacy variables
|
|
|
|
variables.append(key: 'CI_BUILD_REF', value: sha)
|
|
|
|
variables.append(key: 'CI_BUILD_BEFORE_SHA', value: before_sha)
|
|
|
|
variables.append(key: 'CI_BUILD_REF_NAME', value: source_ref)
|
|
|
|
variables.append(key: 'CI_BUILD_REF_SLUG', value: source_ref_slug)
|
|
|
|
variables.append(key: 'CI_BUILD_TAG', value: ref) if tag?
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-09-05 10:49:27 +00:00
|
|
|
def queued_duration
|
|
|
|
return unless started_at
|
|
|
|
|
|
|
|
seconds = (started_at - created_at).to_i
|
2020-08-12 06:09:53 +00:00
|
|
|
seconds unless seconds == 0
|
2016-09-05 10:49:27 +00:00
|
|
|
end
|
|
|
|
|
2016-08-11 18:54:02 +00:00
|
|
|
def update_duration
|
2016-08-29 15:37:15 +00:00
|
|
|
return unless started_at
|
|
|
|
|
2017-09-25 11:22:04 +00:00
|
|
|
self.duration = Gitlab::Ci::Pipeline::Duration.from_pipeline(self)
|
2016-08-02 10:06:31 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
def execute_hooks
|
2020-12-04 15:09:36 +00:00
|
|
|
project.execute_hooks(pipeline_data, :pipeline_hooks) if project.has_active_hooks?(:pipeline_hooks)
|
2021-06-30 06:07:17 +00:00
|
|
|
project.execute_integrations(pipeline_data, :pipeline_hooks) if project.has_active_integrations?(:pipeline_hooks)
|
2016-08-04 16:43:16 +00:00
|
|
|
end
|
|
|
|
|
2017-04-18 19:26:56 +00:00
|
|
|
# All the merge requests for which the current pipeline runs/ran against
|
|
|
|
def all_merge_requests
|
2018-12-05 06:57:00 +00:00
|
|
|
@all_merge_requests ||=
|
2020-02-13 12:08:49 +00:00
|
|
|
if merge_request?
|
2019-02-21 22:37:36 +00:00
|
|
|
MergeRequest.where(id: merge_request_id)
|
2018-12-05 06:57:00 +00:00
|
|
|
else
|
2019-02-21 22:37:36 +00:00
|
|
|
MergeRequest.where(source_project_id: project_id, source_branch: ref)
|
2020-04-14 03:09:39 +00:00
|
|
|
.by_commit_sha(sha)
|
2018-12-05 06:57:00 +00:00
|
|
|
end
|
2017-04-18 19:26:56 +00:00
|
|
|
end
|
|
|
|
|
2019-10-08 09:06:09 +00:00
|
|
|
def all_merge_requests_by_recency
|
|
|
|
all_merge_requests.order(id: :desc)
|
|
|
|
end
|
|
|
|
|
2020-12-16 12:09:53 +00:00
|
|
|
# This returns a list of MRs that point
|
|
|
|
# to the same source project/branch
|
|
|
|
def related_merge_requests
|
|
|
|
if merge_request?
|
|
|
|
# We look for all other MRs that this branch might be pointing to
|
|
|
|
MergeRequest.where(
|
|
|
|
source_project_id: merge_request.source_project_id,
|
|
|
|
source_branch: merge_request.source_branch)
|
|
|
|
else
|
|
|
|
MergeRequest.where(
|
|
|
|
source_project_id: project_id,
|
|
|
|
source_branch: ref)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
# We cannot use `all_merge_requests`, due to race condition
|
|
|
|
# This returns a list of at most 4 open MRs
|
|
|
|
def open_merge_requests_refs
|
|
|
|
strong_memoize(:open_merge_requests_refs) do
|
|
|
|
# We ensure that triggering user can actually read the pipeline
|
|
|
|
related_merge_requests
|
|
|
|
.opened
|
|
|
|
.limit(MAX_OPEN_MERGE_REQUESTS_REFS)
|
|
|
|
.order(id: :desc)
|
|
|
|
.preload(:target_project)
|
|
|
|
.select { |mr| can?(user, :read_merge_request, mr) }
|
|
|
|
.map { |mr| mr.to_reference(project, full: true) }
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-01-13 12:08:04 +00:00
|
|
|
def same_family_pipeline_ids
|
2020-12-09 18:09:48 +00:00
|
|
|
::Gitlab::Ci::PipelineObjectHierarchy.new(
|
2021-06-22 12:08:05 +00:00
|
|
|
self.class.default_scoped.where(id: root_ancestor), options: { project_condition: :same }
|
2020-12-09 18:09:48 +00:00
|
|
|
).base_and_descendants.select(:id)
|
2020-01-13 12:08:04 +00:00
|
|
|
end
|
|
|
|
|
2020-10-13 15:08:53 +00:00
|
|
|
def build_with_artifacts_in_self_and_descendants(name)
|
|
|
|
builds_in_self_and_descendants
|
|
|
|
.ordered_by_pipeline # find job in hierarchical order
|
|
|
|
.with_downloadable_artifacts
|
|
|
|
.find_by_name(name)
|
|
|
|
end
|
|
|
|
|
|
|
|
def builds_in_self_and_descendants
|
|
|
|
Ci::Build.latest.where(pipeline: self_and_descendants)
|
|
|
|
end
|
|
|
|
|
2021-05-25 18:10:42 +00:00
|
|
|
def environments_in_self_and_descendants
|
|
|
|
environment_ids = self_and_descendants.joins(:deployments).select(:'deployments.environment_id')
|
|
|
|
|
|
|
|
Environment.where(id: environment_ids)
|
|
|
|
end
|
|
|
|
|
2021-06-22 12:08:05 +00:00
|
|
|
# With multi-project and parent-child pipelines
|
|
|
|
def self_and_upstreams
|
|
|
|
object_hierarchy.base_and_ancestors
|
|
|
|
end
|
|
|
|
|
|
|
|
# With multi-project and parent-child pipelines
|
|
|
|
def self_with_upstreams_and_downstreams
|
|
|
|
object_hierarchy.all_objects
|
|
|
|
end
|
|
|
|
|
|
|
|
# With only parent-child pipelines
|
|
|
|
def self_and_ancestors
|
|
|
|
object_hierarchy(project_condition: :same).base_and_ancestors
|
|
|
|
end
|
|
|
|
|
|
|
|
# With only parent-child pipelines
|
2020-10-13 15:08:53 +00:00
|
|
|
def self_and_descendants
|
2021-06-22 12:08:05 +00:00
|
|
|
object_hierarchy(project_condition: :same).base_and_descendants
|
2020-10-13 15:08:53 +00:00
|
|
|
end
|
|
|
|
|
2020-11-27 15:09:34 +00:00
|
|
|
def root_ancestor
|
|
|
|
return self unless child?
|
|
|
|
|
2021-06-22 12:08:05 +00:00
|
|
|
object_hierarchy(project_condition: :same)
|
2020-11-27 15:09:34 +00:00
|
|
|
.base_and_ancestors(hierarchy_order: :desc)
|
|
|
|
.first
|
|
|
|
end
|
|
|
|
|
2020-02-08 06:08:50 +00:00
|
|
|
def bridge_triggered?
|
|
|
|
source_bridge.present?
|
|
|
|
end
|
|
|
|
|
|
|
|
def bridge_waiting?
|
|
|
|
source_bridge&.dependent?
|
|
|
|
end
|
|
|
|
|
2020-01-13 12:08:04 +00:00
|
|
|
def child?
|
2020-11-27 15:09:34 +00:00
|
|
|
parent_pipeline? && # child pipelines have `parent_pipeline` source
|
|
|
|
parent_pipeline.present?
|
2020-01-13 12:08:04 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
def parent?
|
|
|
|
child_pipelines.exists?
|
|
|
|
end
|
|
|
|
|
2020-03-03 18:08:16 +00:00
|
|
|
def created_successfully?
|
|
|
|
persisted? && failure_reason.blank?
|
|
|
|
end
|
|
|
|
|
2016-12-08 16:52:24 +00:00
|
|
|
def detailed_status(current_user)
|
2017-02-22 22:54:59 +00:00
|
|
|
Gitlab::Ci::Status::Pipeline::Factory
|
2021-02-02 12:10:15 +00:00
|
|
|
.new(self.present, current_user)
|
2017-02-22 22:54:59 +00:00
|
|
|
.fabricate!
|
2016-12-05 12:23:58 +00:00
|
|
|
end
|
|
|
|
|
2020-03-06 15:08:05 +00:00
|
|
|
def find_job_with_archive_artifacts(name)
|
2020-05-14 12:08:21 +00:00
|
|
|
builds.latest.with_downloadable_artifacts.find_by_name(name)
|
2020-03-06 15:08:05 +00:00
|
|
|
end
|
|
|
|
|
2017-09-12 16:13:07 +00:00
|
|
|
def latest_builds_with_artifacts
|
2017-11-21 16:32:12 +00:00
|
|
|
# We purposely cast the builds to an Array here. Because we always use the
|
|
|
|
# rows if there are more than 0 this prevents us from having to run two
|
|
|
|
# queries: one to get the count and one to get the rows.
|
2019-04-04 18:41:54 +00:00
|
|
|
@latest_builds_with_artifacts ||= builds.latest.with_artifacts_not_expired.to_a
|
2017-09-12 16:13:07 +00:00
|
|
|
end
|
|
|
|
|
2020-06-09 21:08:21 +00:00
|
|
|
def latest_report_builds(reports_scope = ::Ci::JobArtifact.with_reports)
|
|
|
|
builds.latest.with_reports(reports_scope)
|
|
|
|
end
|
|
|
|
|
2020-12-10 15:10:12 +00:00
|
|
|
def latest_test_report_builds
|
2021-06-03 00:09:49 +00:00
|
|
|
latest_report_builds(Ci::JobArtifact.test_reports).preload(:project)
|
2020-12-10 15:10:12 +00:00
|
|
|
end
|
|
|
|
|
2020-09-01 18:10:48 +00:00
|
|
|
def builds_with_coverage
|
2020-09-25 21:09:51 +00:00
|
|
|
builds.latest.with_coverage
|
2020-09-01 18:10:48 +00:00
|
|
|
end
|
|
|
|
|
2020-12-10 15:10:12 +00:00
|
|
|
def builds_with_failed_tests(limit: nil)
|
|
|
|
latest_test_report_builds.failed.limit(limit)
|
|
|
|
end
|
|
|
|
|
2019-04-16 11:06:52 +00:00
|
|
|
def has_reports?(reports_scope)
|
2020-06-09 21:08:21 +00:00
|
|
|
complete? && latest_report_builds(reports_scope).exists?
|
2018-08-02 06:05:07 +00:00
|
|
|
end
|
|
|
|
|
2020-08-21 15:10:03 +00:00
|
|
|
def has_coverage_reports?
|
2021-02-05 12:09:31 +00:00
|
|
|
pipeline_artifacts&.report_exists?(:code_coverage)
|
2020-09-03 18:08:29 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
def can_generate_coverage_reports?
|
|
|
|
has_reports?(Ci::JobArtifact.coverage_reports)
|
2020-08-21 15:10:03 +00:00
|
|
|
end
|
|
|
|
|
2021-02-03 18:09:25 +00:00
|
|
|
def has_codequality_mr_diff_report?
|
2021-02-05 12:09:31 +00:00
|
|
|
pipeline_artifacts&.report_exists?(:code_quality_mr_diff)
|
2021-01-19 21:10:45 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
def can_generate_codequality_reports?
|
|
|
|
has_reports?(Ci::JobArtifact.codequality_reports)
|
|
|
|
end
|
|
|
|
|
2020-06-19 18:08:39 +00:00
|
|
|
def test_report_summary
|
2020-09-02 12:10:35 +00:00
|
|
|
strong_memoize(:test_report_summary) do
|
|
|
|
Gitlab::Ci::Reports::TestReportSummary.new(latest_builds_report_results)
|
|
|
|
end
|
2020-06-19 18:08:39 +00:00
|
|
|
end
|
|
|
|
|
2018-08-02 06:05:07 +00:00
|
|
|
def test_reports
|
|
|
|
Gitlab::Ci::Reports::TestReports.new.tap do |test_reports|
|
2020-12-10 15:10:12 +00:00
|
|
|
latest_test_report_builds.find_each do |build|
|
2018-08-02 06:05:07 +00:00
|
|
|
build.collect_test_reports!(test_reports)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-05-07 09:09:51 +00:00
|
|
|
def accessibility_reports
|
|
|
|
Gitlab::Ci::Reports::AccessibilityReports.new.tap do |accessibility_reports|
|
2020-10-29 12:08:50 +00:00
|
|
|
latest_report_builds(Ci::JobArtifact.accessibility_reports).each do |build|
|
2020-05-07 09:09:51 +00:00
|
|
|
build.collect_accessibility_reports!(accessibility_reports)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-03-17 18:09:44 +00:00
|
|
|
def coverage_reports
|
|
|
|
Gitlab::Ci::Reports::CoverageReports.new.tap do |coverage_reports|
|
2020-12-04 15:09:36 +00:00
|
|
|
latest_report_builds(Ci::JobArtifact.coverage_reports).includes(:project).find_each do |build|
|
2020-03-17 18:09:44 +00:00
|
|
|
build.collect_coverage_reports!(coverage_reports)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-11-23 15:09:37 +00:00
|
|
|
def codequality_reports
|
|
|
|
Gitlab::Ci::Reports::CodequalityReports.new.tap do |codequality_reports|
|
|
|
|
latest_report_builds(Ci::JobArtifact.codequality_reports).each do |build|
|
|
|
|
build.collect_codequality_reports!(codequality_reports)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-04-21 15:21:10 +00:00
|
|
|
def terraform_reports
|
|
|
|
::Gitlab::Ci::Reports::TerraformReports.new.tap do |terraform_reports|
|
2020-06-09 21:08:21 +00:00
|
|
|
latest_report_builds(::Ci::JobArtifact.terraform_reports).each do |build|
|
2020-04-21 15:21:10 +00:00
|
|
|
build.collect_terraform_reports!(terraform_reports)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-07-14 12:09:14 +00:00
|
|
|
def has_archive_artifacts?
|
|
|
|
complete? && builds.latest.with_existing_job_artifacts(Ci::JobArtifact.archive.or(Ci::JobArtifact.metadata)).exists?
|
|
|
|
end
|
|
|
|
|
2019-10-21 15:05:58 +00:00
|
|
|
def has_exposed_artifacts?
|
|
|
|
complete? && builds.latest.with_exposed_artifacts.exists?
|
|
|
|
end
|
|
|
|
|
2018-10-02 11:10:56 +00:00
|
|
|
def branch_updated?
|
|
|
|
strong_memoize(:branch_updated) do
|
|
|
|
push_details.branch_updated?
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-02-13 10:59:34 +00:00
|
|
|
# Returns the modified paths.
|
|
|
|
#
|
|
|
|
# The returned value is
|
|
|
|
# * Array: List of modified paths that should be evaluated
|
|
|
|
# * nil: Modified path can not be evaluated
|
2018-10-02 11:10:56 +00:00
|
|
|
def modified_paths
|
2018-10-03 10:21:41 +00:00
|
|
|
strong_memoize(:modified_paths) do
|
2020-02-13 12:08:49 +00:00
|
|
|
if merge_request?
|
2019-02-13 10:59:34 +00:00
|
|
|
merge_request.modified_paths
|
|
|
|
elsif branch_updated?
|
|
|
|
push_details.modified_paths
|
2021-05-13 18:10:32 +00:00
|
|
|
elsif external_pull_request? && ::Feature.enabled?(:ci_modified_paths_of_external_prs, project, default_enabled: :yaml)
|
|
|
|
external_pull_request.modified_paths
|
2019-02-13 10:59:34 +00:00
|
|
|
end
|
2018-10-02 11:10:56 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-09-24 15:06:34 +00:00
|
|
|
def all_worktree_paths
|
|
|
|
strong_memoize(:all_worktree_paths) do
|
|
|
|
project.repository.ls_files(sha)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def top_level_worktree_paths
|
|
|
|
strong_memoize(:top_level_worktree_paths) do
|
|
|
|
project.repository.tree(sha).blobs.map(&:path)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-10-04 06:23:29 +00:00
|
|
|
def default_branch?
|
|
|
|
ref == project.default_branch
|
|
|
|
end
|
|
|
|
|
2020-02-13 12:08:49 +00:00
|
|
|
def merge_request?
|
|
|
|
merge_request_id.present?
|
2019-02-20 06:37:49 +00:00
|
|
|
end
|
|
|
|
|
2021-05-13 18:10:32 +00:00
|
|
|
def external_pull_request?
|
|
|
|
external_pull_request_id.present?
|
|
|
|
end
|
|
|
|
|
2019-02-20 06:37:49 +00:00
|
|
|
def detached_merge_request_pipeline?
|
2020-02-13 12:08:49 +00:00
|
|
|
merge_request? && target_sha.nil?
|
2019-02-20 06:37:49 +00:00
|
|
|
end
|
|
|
|
|
2019-03-21 13:08:32 +00:00
|
|
|
def legacy_detached_merge_request_pipeline?
|
|
|
|
detached_merge_request_pipeline? && !merge_request_ref?
|
|
|
|
end
|
|
|
|
|
2021-03-01 06:10:47 +00:00
|
|
|
def merged_result_pipeline?
|
2020-02-13 12:08:49 +00:00
|
|
|
merge_request? && target_sha.present?
|
2019-02-20 06:37:49 +00:00
|
|
|
end
|
|
|
|
|
2019-03-21 13:08:32 +00:00
|
|
|
def merge_request_ref?
|
|
|
|
MergeRequest.merge_request_ref?(ref)
|
|
|
|
end
|
|
|
|
|
2019-03-21 15:31:09 +00:00
|
|
|
def matches_sha_or_source_sha?(sha)
|
|
|
|
self.sha == sha || self.source_sha == sha
|
|
|
|
end
|
|
|
|
|
2019-04-09 14:53:44 +00:00
|
|
|
def triggered_by?(current_user)
|
|
|
|
user == current_user
|
|
|
|
end
|
|
|
|
|
2019-04-25 08:23:39 +00:00
|
|
|
def source_ref
|
2020-02-13 12:08:49 +00:00
|
|
|
if merge_request?
|
2019-04-25 08:23:39 +00:00
|
|
|
merge_request.source_branch
|
|
|
|
else
|
|
|
|
ref
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def source_ref_slug
|
|
|
|
Gitlab::Utils.slugify(source_ref.to_s)
|
|
|
|
end
|
|
|
|
|
2019-05-02 18:27:35 +00:00
|
|
|
def find_stage_by_name!(name)
|
|
|
|
stages.find_by!(name: name)
|
|
|
|
end
|
|
|
|
|
2020-06-29 12:09:20 +00:00
|
|
|
def full_error_messages
|
2019-06-26 12:29:35 +00:00
|
|
|
errors ? errors.full_messages.to_sentence : ""
|
|
|
|
end
|
|
|
|
|
2019-08-28 07:51:26 +00:00
|
|
|
def merge_request_event_type
|
2020-02-13 12:08:49 +00:00
|
|
|
return unless merge_request?
|
2019-08-28 07:51:26 +00:00
|
|
|
|
|
|
|
strong_memoize(:merge_request_event_type) do
|
2021-03-01 06:10:47 +00:00
|
|
|
if merged_result_pipeline?
|
2019-08-28 07:51:26 +00:00
|
|
|
:merged_result
|
2019-09-10 18:18:39 +00:00
|
|
|
elsif detached_merge_request_pipeline?
|
|
|
|
:detached
|
2019-08-28 07:51:26 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-09-27 18:06:20 +00:00
|
|
|
def persistent_ref
|
|
|
|
@persistent_ref ||= PersistentRef.new(pipeline: self)
|
|
|
|
end
|
|
|
|
|
2020-09-07 12:08:27 +00:00
|
|
|
def dangling?
|
|
|
|
Enums::Ci::Pipeline.dangling_sources.key?(source.to_sym)
|
2020-02-13 18:09:00 +00:00
|
|
|
end
|
|
|
|
|
2020-03-18 09:09:31 +00:00
|
|
|
def source_ref_path
|
|
|
|
if branch? || merge_request?
|
|
|
|
Gitlab::Git::BRANCH_REF_PREFIX + source_ref.to_s
|
|
|
|
elsif tag?
|
|
|
|
Gitlab::Git::TAG_REF_PREFIX + source_ref.to_s
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-05-15 15:08:04 +00:00
|
|
|
# Set scheduling type of processables if they were created before scheduling_type
|
|
|
|
# data was deployed (https://gitlab.com/gitlab-org/gitlab/-/merge_requests/22246).
|
|
|
|
def ensure_scheduling_type!
|
|
|
|
processables.populate_scheduling_type!
|
|
|
|
end
|
|
|
|
|
2020-06-10 09:08:35 +00:00
|
|
|
def ensure_ci_ref!
|
|
|
|
self.ci_ref = Ci::Ref.ensure_for(self)
|
|
|
|
end
|
|
|
|
|
2020-09-17 12:09:37 +00:00
|
|
|
# We need `base_and_ancestors` in a specific order to "break" when needed.
|
|
|
|
# If we use `find_each`, then the order is broken.
|
|
|
|
# rubocop:disable Rails/FindEach
|
2021-04-30 18:10:09 +00:00
|
|
|
def reset_source_bridge!(current_user)
|
|
|
|
if ::Feature.enabled?(:ci_reset_bridge_with_subsequent_jobs, project, default_enabled: :yaml)
|
|
|
|
return unless bridge_waiting?
|
2020-09-17 12:09:37 +00:00
|
|
|
|
2021-04-30 18:10:09 +00:00
|
|
|
source_bridge.pending!
|
|
|
|
Ci::AfterRequeueJobService.new(project, current_user).execute(source_bridge) # rubocop:disable CodeReuse/ServiceClass
|
|
|
|
else
|
2021-06-22 12:08:05 +00:00
|
|
|
self_and_upstreams.includes(:source_bridge).each do |pipeline|
|
2021-04-30 18:10:09 +00:00
|
|
|
break unless pipeline.bridge_waiting?
|
|
|
|
|
|
|
|
pipeline.source_bridge.pending!
|
|
|
|
end
|
2020-09-17 12:09:37 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
# rubocop:enable Rails/FindEach
|
|
|
|
|
2021-01-26 12:09:27 +00:00
|
|
|
# EE-only
|
|
|
|
def merge_train_pipeline?
|
|
|
|
false
|
|
|
|
end
|
|
|
|
|
2021-02-10 09:09:38 +00:00
|
|
|
def security_reports(report_types: [])
|
|
|
|
reports_scope = report_types.empty? ? ::Ci::JobArtifact.security_reports : ::Ci::JobArtifact.security_reports(file_types: report_types)
|
|
|
|
|
|
|
|
::Gitlab::Ci::Reports::Security::Reports.new(self).tap do |security_reports|
|
|
|
|
latest_report_builds(reports_scope).each do |build|
|
|
|
|
build.collect_security_reports!(security_reports)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2021-05-25 09:10:54 +00:00
|
|
|
def build_matchers
|
2021-06-16 18:10:35 +00:00
|
|
|
self.builds.latest.build_matchers(project)
|
2021-05-25 09:10:54 +00:00
|
|
|
end
|
|
|
|
|
2016-06-02 15:17:23 +00:00
|
|
|
private
|
|
|
|
|
2020-07-13 12:09:18 +00:00
|
|
|
def add_message(severity, content)
|
|
|
|
messages.build(severity: severity, content: content)
|
|
|
|
end
|
|
|
|
|
2016-08-04 16:43:16 +00:00
|
|
|
def pipeline_data
|
2020-12-04 15:09:36 +00:00
|
|
|
strong_memoize(:pipeline_data) do
|
|
|
|
Gitlab::DataBuilder::Pipeline.build(self)
|
|
|
|
end
|
2016-04-11 14:55:40 +00:00
|
|
|
end
|
2016-07-03 23:58:58 +00:00
|
|
|
|
2020-11-27 15:09:34 +00:00
|
|
|
def merge_request_diff_sha
|
|
|
|
return unless merge_request?
|
|
|
|
|
2021-03-01 06:10:47 +00:00
|
|
|
if merged_result_pipeline?
|
2020-11-27 15:09:34 +00:00
|
|
|
source_sha
|
|
|
|
else
|
|
|
|
sha
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def merge_request_diff
|
|
|
|
return unless merge_request?
|
|
|
|
|
|
|
|
merge_request.merge_request_diff_for(merge_request_diff_sha)
|
|
|
|
end
|
|
|
|
|
2018-10-02 11:10:56 +00:00
|
|
|
def push_details
|
|
|
|
strong_memoize(:push_details) do
|
2018-10-22 09:37:52 +00:00
|
|
|
Gitlab::Git::Push.new(project, before_sha, sha, git_ref)
|
2018-10-02 11:10:56 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2018-10-22 09:37:52 +00:00
|
|
|
def git_ref
|
2019-03-27 23:15:26 +00:00
|
|
|
strong_memoize(:git_ref) do
|
2020-02-13 12:08:49 +00:00
|
|
|
if merge_request?
|
2019-03-17 06:23:11 +00:00
|
|
|
##
|
|
|
|
# In the future, we're going to change this ref to
|
|
|
|
# merge request's merged reference, such as "refs/merge-requests/:iid/merge".
|
|
|
|
# In order to do that, we have to update GitLab-Runner's source pulling
|
|
|
|
# logic.
|
|
|
|
# See https://gitlab.com/gitlab-org/gitlab-runner/merge_requests/1092
|
|
|
|
Gitlab::Git::BRANCH_REF_PREFIX + ref.to_s
|
|
|
|
else
|
|
|
|
super
|
|
|
|
end
|
2018-10-02 11:10:56 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2016-07-03 23:58:58 +00:00
|
|
|
def keep_around_commits
|
2016-07-15 22:33:30 +00:00
|
|
|
return unless project
|
2016-07-19 12:59:38 +00:00
|
|
|
|
2018-08-16 23:55:00 +00:00
|
|
|
project.repository.keep_around(self.sha, self.before_sha)
|
2016-07-03 23:58:58 +00:00
|
|
|
end
|
2021-06-22 12:08:05 +00:00
|
|
|
|
|
|
|
# Without using `unscoped`, caller scope is also included into the query.
|
|
|
|
# Using `unscoped` here will be redundant after Rails 6.1
|
|
|
|
def object_hierarchy(options = {})
|
|
|
|
::Gitlab::Ci::PipelineObjectHierarchy
|
|
|
|
.new(self.class.unscoped.where(id: id), options: options)
|
|
|
|
end
|
2015-08-26 01:42:46 +00:00
|
|
|
end
|
|
|
|
end
|
2019-09-13 13:26:31 +00:00
|
|
|
|
2021-05-11 21:10:21 +00:00
|
|
|
Ci::Pipeline.prepend_mod_with('Ci::Pipeline')
|