debian-mirror-gitlab/lib/gitlab/exclusive_lease.rb

144 lines
4.3 KiB
Ruby
Raw Normal View History

2018-12-13 13:39:08 +05:30
# frozen_string_literal: true
2017-08-17 22:00:37 +05:30
require 'securerandom'
2016-04-02 18:10:28 +05:30
module Gitlab
# This class implements an 'exclusive lease'. We call it a 'lease'
# because it has a set expiry time. We call it 'exclusive' because only
# one caller may obtain a lease for a given key at a time. The
# implementation is intended to work across GitLab processes and across
2017-08-17 22:00:37 +05:30
# servers. It is a cheap alternative to using SQL queries and updates:
2016-04-02 18:10:28 +05:30
# you do not need to change the SQL schema to start using
# ExclusiveLease.
#
class ExclusiveLease
2020-05-24 23:13:21 +05:30
PREFIX = 'gitlab:exclusive_lease'
NoKey = Class.new(ArgumentError)
2021-04-29 21:17:54 +05:30
LUA_CANCEL_SCRIPT = <<~EOS
2017-08-17 22:00:37 +05:30
local key, uuid = KEYS[1], ARGV[1]
if redis.call("get", key) == uuid then
redis.call("del", key)
end
EOS
2021-04-29 21:17:54 +05:30
LUA_RENEW_SCRIPT = <<~EOS
2017-09-10 17:25:29 +05:30
local key, uuid, ttl = KEYS[1], ARGV[1], ARGV[2]
if redis.call("get", key) == uuid then
redis.call("expire", key, ttl)
return uuid
end
EOS
2018-03-17 18:26:18 +05:30
def self.get_uuid(key)
Gitlab::Redis::SharedState.with do |redis|
redis.get(redis_shared_state_key(key)) || false
end
end
2021-09-04 01:27:46 +05:30
# yield to the {block} at most {count} times per {period}
#
# Defaults to once per hour.
#
# For example:
#
# # toot the train horn at most every 20min:
# throttle(locomotive.id, count: 3, period: 1.hour) { toot_train_horn }
# # Brake suddenly at most once every minute:
# throttle(locomotive.id, period: 1.minute) { brake_suddenly }
# # Specify a uniqueness group:
# throttle(locomotive.id, group: :locomotive_brake) { brake_suddenly }
#
# If a group is not specified, each block will get a separate group to itself.
def self.throttle(key, group: nil, period: 1.hour, count: 1, &block)
group ||= block.source_location.join(':')
return if new("el:throttle:#{group}:#{key}", timeout: period.to_i / count).waiting?
yield
end
2017-08-17 22:00:37 +05:30
def self.cancel(key, uuid)
2020-05-24 23:13:21 +05:30
return unless key.present?
2017-09-10 17:25:29 +05:30
Gitlab::Redis::SharedState.with do |redis|
2020-05-24 23:13:21 +05:30
redis.eval(LUA_CANCEL_SCRIPT, keys: [ensure_prefixed_key(key)], argv: [uuid])
2017-08-17 22:00:37 +05:30
end
end
2017-09-10 17:25:29 +05:30
def self.redis_shared_state_key(key)
2020-05-24 23:13:21 +05:30
"#{PREFIX}:#{key}"
end
def self.ensure_prefixed_key(key)
raise NoKey unless key.present?
key.start_with?(PREFIX) ? key : redis_shared_state_key(key)
2017-08-17 22:00:37 +05:30
end
2018-05-09 12:01:36 +05:30
# Removes any existing exclusive_lease from redis
# Don't run this in a live system without making sure no one is using the leases
def self.reset_all!(scope = '*')
Gitlab::Redis::SharedState.with do |redis|
redis.scan_each(match: redis_shared_state_key(scope)).each do |key|
redis.del(key)
end
end
end
2018-03-17 18:26:18 +05:30
def initialize(key, uuid: nil, timeout:)
2017-09-10 17:25:29 +05:30
@redis_shared_state_key = self.class.redis_shared_state_key(key)
2017-08-17 22:00:37 +05:30
@timeout = timeout
2018-03-17 18:26:18 +05:30
@uuid = uuid || SecureRandom.uuid
2016-04-02 18:10:28 +05:30
end
2017-08-17 22:00:37 +05:30
# Try to obtain the lease. Return lease UUID on success,
2016-04-02 18:10:28 +05:30
# false if the lease is already taken.
def try_obtain
# Performing a single SET is atomic
2017-09-10 17:25:29 +05:30
Gitlab::Redis::SharedState.with do |redis|
redis.set(@redis_shared_state_key, @uuid, nx: true, ex: @timeout) && @uuid
end
end
2021-09-04 01:27:46 +05:30
# This lease is waiting to obtain
def waiting?
!try_obtain
end
2017-09-10 17:25:29 +05:30
# Try to renew an existing lease. Return lease UUID on success,
# false if the lease is taken by a different UUID or inexistent.
def renew
Gitlab::Redis::SharedState.with do |redis|
result = redis.eval(LUA_RENEW_SCRIPT, keys: [@redis_shared_state_key], argv: [@uuid, @timeout])
result == @uuid
2016-06-02 11:05:42 +05:30
end
2016-04-02 18:10:28 +05:30
end
2016-11-03 12:29:30 +05:30
# Returns true if the key for this lease is set.
def exists?
2017-09-10 17:25:29 +05:30
Gitlab::Redis::SharedState.with do |redis|
2022-11-25 23:54:43 +05:30
redis.exists?(@redis_shared_state_key) # rubocop:disable CodeReuse/ActiveRecord
2016-11-03 12:29:30 +05:30
end
end
2018-03-17 18:26:18 +05:30
# Returns the TTL of the Redis key.
#
# This method will return `nil` if no TTL could be obtained.
def ttl
Gitlab::Redis::SharedState.with do |redis|
ttl = redis.ttl(@redis_shared_state_key)
2020-10-24 23:57:45 +05:30
ttl if ttl > 0
2018-03-17 18:26:18 +05:30
end
end
2020-05-24 23:13:21 +05:30
# Gives up this lease, allowing it to be obtained by others.
def cancel
self.class.cancel(@redis_shared_state_key, @uuid)
end
2016-04-02 18:10:28 +05:30
end
end
2019-12-04 20:38:33 +05:30
2021-06-08 01:23:25 +05:30
Gitlab::ExclusiveLease.prepend_mod_with('Gitlab::ExclusiveLease')