debian-mirror-gitlab/app/models/ci/runner.rb

375 lines
12 KiB
Ruby
Raw Normal View History

2018-11-18 11:00:15 +05:30
# frozen_string_literal: true
2015-09-25 12:07:36 +05:30
module Ci
2019-07-07 11:18:12 +05:30
class Runner < ApplicationRecord
2018-03-17 18:26:18 +05:30
extend Gitlab::Ci::Model
include Gitlab::SQL::Pattern
include RedisCacheable
2018-05-09 12:01:36 +05:30
include ChronicDurationAttribute
2018-12-05 23:21:45 +05:30
include FromUnion
2019-02-15 15:39:39 +05:30
include TokenAuthenticatable
2020-01-01 13:55:28 +05:30
include IgnorableColumns
2019-02-15 15:39:39 +05:30
2019-07-07 11:18:12 +05:30
add_authentication_token_field :token, encrypted: -> { Feature.enabled?(:ci_runners_tokens_optional_encryption, default_enabled: true) ? :optional : :required }
2018-12-05 23:21:45 +05:30
enum access_level: {
not_protected: 0,
ref_protected: 1
}
enum runner_type: {
instance_type: 1,
group_type: 2,
project_type: 3
}
2015-10-24 18:46:33 +05:30
2020-06-23 00:09:42 +05:30
# This `ONLINE_CONTACT_TIMEOUT` needs to be larger than
# `RUNNER_QUEUE_EXPIRY_TIME+UPDATE_CONTACT_COLUMN_EVERY`
#
ONLINE_CONTACT_TIMEOUT = 2.hours
# The `RUNNER_QUEUE_EXPIRY_TIME` indicates the longest interval that
# Runner request needs to be refreshed by Rails instead of being handled
# by Workhorse
2019-12-04 20:38:33 +05:30
RUNNER_QUEUE_EXPIRY_TIME = 1.hour
2020-06-23 00:09:42 +05:30
# The `UPDATE_CONTACT_COLUMN_EVERY` defines how often the Runner DB entry can be updated
2019-12-04 20:38:33 +05:30
UPDATE_CONTACT_COLUMN_EVERY = (40.minutes..55.minutes).freeze
2018-12-05 23:21:45 +05:30
AVAILABLE_TYPES_LEGACY = %w[specific shared].freeze
AVAILABLE_TYPES = runner_types.keys.freeze
AVAILABLE_STATUSES = %w[active paused online offline].freeze
AVAILABLE_SCOPES = (AVAILABLE_TYPES_LEGACY + AVAILABLE_TYPES + AVAILABLE_STATUSES).freeze
2019-12-04 20:38:33 +05:30
2018-05-09 12:01:36 +05:30
FORM_EDITABLE = %i[description tag_list active run_untagged locked access_level maximum_timeout_human_readable].freeze
2020-04-22 19:07:51 +05:30
MINUTES_COST_FACTOR_FIELDS = %i[public_projects_minutes_cost_factor private_projects_minutes_cost_factor].freeze
2016-06-02 11:05:42 +05:30
2020-01-01 13:55:28 +05:30
ignore_column :is_shared, remove_after: '2019-12-15', remove_with: '12.6'
2018-11-08 19:23:39 +05:30
2017-08-17 22:00:37 +05:30
has_many :builds
2018-11-08 19:23:39 +05:30
has_many :runner_projects, inverse_of: :runner, dependent: :destroy # rubocop:disable Cop/ActiveRecordDependent
2017-08-17 22:00:37 +05:30
has_many :projects, through: :runner_projects
2018-11-08 19:23:39 +05:30
has_many :runner_namespaces, inverse_of: :runner
2018-10-15 14:42:47 +05:30
has_many :groups, through: :runner_namespaces
2015-09-25 12:07:36 +05:30
has_one :last_build, ->() { order('id DESC') }, class_name: 'Ci::Build'
2019-02-15 15:39:39 +05:30
before_save :ensure_token
2015-09-25 12:07:36 +05:30
2018-10-15 14:42:47 +05:30
scope :active, -> { where(active: true) }
scope :paused, -> { where(active: false) }
2019-12-04 20:38:33 +05:30
scope :online, -> { where('contacted_at > ?', online_contact_time_deadline) }
2018-12-05 23:21:45 +05:30
# The following query using negation is cheaper than using `contacted_at <= ?`
# because there are less runners online than have been created. The
# resulting query is quickly finding online ones and then uses the regular
# indexed search and rejects the ones that are in the previous set. If we
# did `contacted_at <= ?` the query would effectively have to do a seq
# scan.
scope :offline, -> { where.not(id: online) }
2018-10-15 14:42:47 +05:30
scope :ordered, -> { order(id: :desc) }
2015-09-25 12:07:36 +05:30
2019-12-04 20:38:33 +05:30
scope :with_recent_runner_queue, -> { where('contacted_at > ?', recent_queue_deadline) }
2018-11-08 19:23:39 +05:30
# BACKWARD COMPATIBILITY: There are needed to maintain compatibility with `AVAILABLE_SCOPES` used by `lib/api/runners.rb`
scope :deprecated_shared, -> { instance_type }
2019-02-15 15:39:39 +05:30
scope :deprecated_specific, -> { project_type.or(group_type) }
2018-11-08 19:23:39 +05:30
2018-10-15 14:42:47 +05:30
scope :belonging_to_project, -> (project_id) {
joins(:runner_projects).where(ci_runner_projects: { project_id: project_id })
}
2020-04-22 19:07:51 +05:30
scope :belonging_to_group, -> (group_id, include_ancestors: false) {
groups = ::Group.where(id: group_id)
if include_ancestors
groups = Gitlab::ObjectHierarchy.new(groups).base_and_ancestors
end
joins(:runner_namespaces).where(ci_runner_namespaces: { namespace_id: groups })
}
2020-06-23 00:09:42 +05:30
scope :belonging_to_group_or_project, -> (group_id, project_id) {
groups = ::Group.where(id: group_id)
group_runners = joins(:runner_namespaces).where(ci_runner_namespaces: { namespace_id: groups })
project_runners = joins(:runner_projects).where(ci_runner_projects: { project_id: project_id })
union_sql = ::Gitlab::SQL::Union.new([group_runners, project_runners]).to_sql
from("(#{union_sql}) #{table_name}")
}
2018-10-15 14:42:47 +05:30
scope :belonging_to_parent_group_of_project, -> (project_id) {
project_groups = ::Group.joins(:projects).where(projects: { id: project_id })
2019-02-15 15:39:39 +05:30
hierarchy_groups = Gitlab::ObjectHierarchy.new(project_groups).base_and_ancestors
2018-10-15 14:42:47 +05:30
joins(:groups).where(namespaces: { id: hierarchy_groups })
}
2018-11-08 19:23:39 +05:30
scope :owned_or_instance_wide, -> (project_id) do
2018-12-05 23:21:45 +05:30
from_union(
[
belonging_to_project(project_id),
belonging_to_parent_group_of_project(project_id),
instance_type
],
2018-10-15 14:42:47 +05:30
remove_duplicates: false
)
2016-04-02 18:10:28 +05:30
end
2016-06-22 15:30:34 +05:30
scope :assignable_for, ->(project) do
# FIXME: That `to_sql` is needed to workaround a weird Rails bug.
# Without that, placeholders would miss one and couldn't match.
2018-12-05 23:21:45 +05:30
#
# We use "unscoped" here so that any current Ci::Runner filters don't
# apply to the inner query, which is not necessary.
exclude_runners = unscoped { project.runners.select(:id) }.to_sql
2017-09-10 17:25:29 +05:30
where(locked: false)
2018-12-05 23:21:45 +05:30
.where.not("ci_runners.id IN (#{exclude_runners})")
2018-11-08 19:23:39 +05:30
.project_type
2016-06-22 15:30:34 +05:30
end
2018-12-05 23:21:45 +05:30
scope :order_contacted_at_asc, -> { order(contacted_at: :asc) }
scope :order_created_at_desc, -> { order(created_at: :desc) }
2019-07-07 11:18:12 +05:30
scope :with_tags, -> { preload(:tags) }
2018-12-05 23:21:45 +05:30
2016-06-02 11:05:42 +05:30
validate :tag_constraints
2018-03-17 18:26:18 +05:30
validates :access_level, presence: true
2018-11-08 19:23:39 +05:30
validates :runner_type, presence: true
validate :no_projects, unless: :project_type?
validate :no_groups, unless: :group_type?
validate :any_project, if: :project_type?
validate :exactly_one_group, if: :group_type?
2016-06-02 11:05:42 +05:30
2015-09-25 12:07:36 +05:30
acts_as_taggable
2017-08-17 22:00:37 +05:30
after_destroy :cleanup_runner_queue
2018-11-08 19:23:39 +05:30
cached_attr_reader :version, :revision, :platform, :architecture, :ip_address, :contacted_at
2018-03-17 18:26:18 +05:30
2019-02-15 15:39:39 +05:30
chronic_duration_attr :maximum_timeout_human_readable, :maximum_timeout,
error_message: 'Maximum job timeout has a value which could not be accepted'
2018-05-09 12:01:36 +05:30
validates :maximum_timeout, allow_nil: true,
numericality: { greater_than_or_equal_to: 600,
message: 'needs to be at least 10 minutes' }
2020-04-22 19:07:51 +05:30
validates :public_projects_minutes_cost_factor, :private_projects_minutes_cost_factor,
allow_nil: false,
numericality: { greater_than_or_equal_to: 0.0,
message: 'needs to be non-negative' }
2016-06-02 11:05:42 +05:30
# Searches for runners matching the given query.
#
2020-06-23 00:09:42 +05:30
# This method uses ILIKE on PostgreSQL.
2016-06-02 11:05:42 +05:30
#
# This method performs a *partial* match on tokens, thus a query for "a"
# will match any runner where the token contains the letter "a". As a result
# you should *not* use this method for non-admin purposes as otherwise users
# might be able to query a list of all runners.
#
2020-06-23 00:09:42 +05:30
# query - The search query as a String.
2016-06-02 11:05:42 +05:30
#
# Returns an ActiveRecord::Relation.
2015-09-25 12:07:36 +05:30
def self.search(query)
2018-03-17 18:26:18 +05:30
fuzzy_search(query, [:token, :description])
2015-09-25 12:07:36 +05:30
end
2019-12-04 20:38:33 +05:30
def self.online_contact_time_deadline
2017-09-10 17:25:29 +05:30
ONLINE_CONTACT_TIMEOUT.ago
end
2019-12-04 20:38:33 +05:30
def self.recent_queue_deadline
# we add queue expiry + online
# - contacted_at can be updated at any time within this interval
# we have always accurate `contacted_at` but it is stored in Redis
# and not persisted in database
(ONLINE_CONTACT_TIMEOUT + RUNNER_QUEUE_EXPIRY_TIME).ago
end
2018-12-05 23:21:45 +05:30
def self.order_by(order)
if order == 'contacted_asc'
order_contacted_at_asc
else
order_created_at_desc
end
end
2015-09-25 12:07:36 +05:30
def assign_to(project, current_user = nil)
2018-11-08 19:23:39 +05:30
if instance_type?
2018-10-15 14:42:47 +05:30
self.runner_type = :project_type
elsif group_type?
raise ArgumentError, 'Transitioning a group runner to a project runner is not supported'
end
2018-11-08 19:23:39 +05:30
begin
transaction do
self.projects << project
self.save!
end
rescue ActiveRecord::RecordInvalid => e
self.errors.add(:assign_to, e.message)
false
end
2015-09-25 12:07:36 +05:30
end
def display_name
return short_sha if description.blank?
2015-09-25 12:07:36 +05:30
description
end
2015-10-24 18:46:33 +05:30
def online?
2019-12-04 20:38:33 +05:30
contacted_at && contacted_at > self.class.online_contact_time_deadline
2015-10-24 18:46:33 +05:30
end
def status
if contacted_at.nil?
:not_connected
elsif active?
online? ? :online : :offline
else
:paused
end
end
2015-09-25 12:07:36 +05:30
def belongs_to_one_project?
runner_projects.count == 1
end
2018-10-15 14:42:47 +05:30
def assigned_to_group?
runner_namespaces.any?
end
def assigned_to_project?
runner_projects.any?
end
2016-06-22 15:30:34 +05:30
def can_pick?(build)
2018-03-17 18:26:18 +05:30
return false if self.ref_protected? && !build.protected?
assignable_for?(build.project_id) && accepting_tags?(build)
2016-06-22 15:30:34 +05:30
end
2015-09-25 12:07:36 +05:30
def only_for?(project)
projects == [project]
end
def short_sha
2015-10-24 18:46:33 +05:30
token[0...8] if token
2015-09-25 12:07:36 +05:30
end
2016-06-02 11:05:42 +05:30
def has_tags?
tag_list.any?
end
2016-08-24 12:49:21 +05:30
def predefined_variables
2018-05-09 12:01:36 +05:30
Gitlab::Ci::Variables::Collection.new
.append(key: 'CI_RUNNER_ID', value: id.to_s)
.append(key: 'CI_RUNNER_DESCRIPTION', value: description)
.append(key: 'CI_RUNNER_TAGS', value: tag_list.to_s)
2016-08-24 12:49:21 +05:30
end
2017-08-17 22:00:37 +05:30
def tick_runner_queue
SecureRandom.hex.tap do |new_update|
::Gitlab::Workhorse.set_key_and_notify(runner_queue_key, new_update,
expire: RUNNER_QUEUE_EXPIRY_TIME, overwrite: true)
end
end
def ensure_runner_queue_value
new_value = SecureRandom.hex
::Gitlab::Workhorse.set_key_and_notify(runner_queue_key, new_value,
expire: RUNNER_QUEUE_EXPIRY_TIME, overwrite: false)
end
2018-03-17 18:26:18 +05:30
def runner_queue_value_latest?(value)
2017-08-17 22:00:37 +05:30
ensure_runner_queue_value == value if value.present?
end
2020-06-23 00:09:42 +05:30
def heartbeat(values)
2018-03-27 19:54:05 +05:30
values = values&.slice(:version, :revision, :platform, :architecture, :ip_address) || {}
2020-06-23 00:09:42 +05:30
values[:contacted_at] = Time.current
2018-03-17 18:26:18 +05:30
cache_attributes(values)
2018-11-08 19:23:39 +05:30
# We save data without validation, it will always change due to `contacted_at`
self.update_columns(values) if persist_cached_data?
2018-03-17 18:26:18 +05:30
end
2018-10-15 14:42:47 +05:30
def pick_build!(build)
if can_pick?(build)
tick_runner_queue
end
end
2019-02-15 15:39:39 +05:30
def uncached_contacted_at
read_attribute(:contacted_at)
end
2016-06-02 11:05:42 +05:30
private
2017-08-17 22:00:37 +05:30
def cleanup_runner_queue
2019-10-12 21:52:04 +05:30
Gitlab::Redis::SharedState.with do |redis|
2017-08-17 22:00:37 +05:30
redis.del(runner_queue_key)
end
end
def runner_queue_key
"runner:build_queue:#{self.token}"
end
2018-03-17 18:26:18 +05:30
def persist_cached_data?
# Use a random threshold to prevent beating DB updates.
2019-12-04 20:38:33 +05:30
contacted_at_max_age = Random.rand(UPDATE_CONTACT_COLUMN_EVERY)
2018-03-17 18:26:18 +05:30
real_contacted_at = read_attribute(:contacted_at)
real_contacted_at.nil? ||
2020-06-23 00:09:42 +05:30
(Time.current - real_contacted_at) >= contacted_at_max_age
2018-03-17 18:26:18 +05:30
end
2016-06-02 11:05:42 +05:30
def tag_constraints
unless has_tags? || run_untagged?
errors.add(:tags_list,
'can not be empty when runner is not allowed to pick untagged jobs')
end
end
2016-06-22 15:30:34 +05:30
2018-03-17 18:26:18 +05:30
def assignable_for?(project_id)
2018-11-08 19:23:39 +05:30
self.class.owned_or_instance_wide(project_id).where(id: self.id).any?
end
def no_projects
if projects.any?
errors.add(:runner, 'cannot have projects assigned')
end
2018-10-15 14:42:47 +05:30
end
2018-11-08 19:23:39 +05:30
def no_groups
if groups.any?
errors.add(:runner, 'cannot have groups assigned')
2018-10-15 14:42:47 +05:30
end
2018-11-08 19:23:39 +05:30
end
def any_project
unless projects.any?
errors.add(:runner, 'needs to be assigned to at least one project')
end
end
2018-10-15 14:42:47 +05:30
2018-11-08 19:23:39 +05:30
def exactly_one_group
unless groups.one?
errors.add(:runner, 'needs to be assigned to exactly one group')
2018-10-15 14:42:47 +05:30
end
2016-06-22 15:30:34 +05:30
end
def accepting_tags?(build)
(run_untagged? || build.has_tags?) && (build.tag_list - tag_list).empty?
end
2015-09-25 12:07:36 +05:30
end
end
2019-12-04 20:38:33 +05:30
Ci::Runner.prepend_if_ee('EE::Ci::Runner')