class SidekiqUniqueJobs::Digests


@author Mikael Henriksson <mikael@zoolutions.se>
Class Changelogs provides access to the changelog entries

def add(digest)

Parameters:
  • digest (String) -- the digest to add 
def add(digest)
  redis { |conn| conn.zadd(key, now_f, digest) }
end

def delete_by_digest(digest) # rubocop:disable Metrics/MethodLength

Parameters:
  • digest (String) -- a unique digest to delete 
def delete_by_digest(digest) # rubocop:disable Metrics/MethodLength
  result, elapsed = timed do
    call_script(:delete_by_digest, [
                  digest,
                  "#{digest}:QUEUED",
                  "#{digest}:PRIMED",
                  "#{digest}:LOCKED",
                  "#{digest}:RUN",
                  "#{digest}:RUN:QUEUED",
                  "#{digest}:RUN:PRIMED",
                  "#{digest}:RUN:LOCKED",
                  key,
                ])
  end
  log_info("#{__method__}(#{digest}) completed in #{elapsed}ms")
  result
end

def delete_by_pattern(pattern, count: DEFAULT_COUNT)

Returns:
  • (Array) - with unique digests

Parameters:
  • count (Integer) -- the maximum number
  • pattern (String) -- a key pattern to match with 
def delete_by_pattern(pattern, count: DEFAULT_COUNT)
  result, elapsed = timed do
    digests = entries(pattern: pattern, count: count).keys
    redis { |conn| BatchDelete.call(digests, conn) }
  end
  log_info("#{__method__}(#{pattern}, count: #{count}) completed in #{elapsed}ms")
  result
end

def entries(pattern: SCAN_PATTERN, count: DEFAULT_COUNT)

Returns:
  • (Array) - an array of digests matching the given pattern

Parameters:
  • count (Integer) -- DEFAULT_COUNT the number of entries to return
  • pattern (String) -- SCAN_PATTERN the match pattern to search for 
def entries(pattern: SCAN_PATTERN, count: DEFAULT_COUNT)
  options = {}
  options[:match] = pattern
  options[:count] = count if count
  result = redis { |conn| conn.zscan_each(key, **options).to_a }
  result.each_with_object({}) do |entry, hash|
    hash[entry[0]] = entry[1]
  end
end

def initialize 

def initialize
  super(DIGESTS)
end

def page(cursor: 0, pattern: SCAN_PATTERN, page_size: 100)

Returns:
  • (Array>) - total_size, next_cursor, locks

Parameters:
  • page_size (Integer) -- 100 the size per page
  • pattern (String) -- SCAN_PATTERN the match pattern to search for
  • cursor (Integer) -- the cursor for this iteration 
def page(cursor: 0, pattern: SCAN_PATTERN, page_size: 100)
  redis do |conn|
    total_size, digests = conn.multi do
      conn.zcard(key)
      conn.zscan(key, cursor, match: pattern, count: page_size)
    end
    [
      total_size,
      digests[0], # next_cursor
      digests[1].map { |digest, score| Lock.new(digest, time: score) }, # entries
    ]
  end
end