class Progressrus

Constants

VERSION

Attributes

mutex[R]
completed?[R]
completed_at[R]
count[R]
error_count[R]
expires_at[R]
failed?[R]
failed_at[R]
id[R]
name[R]
params[RW]
scope[R]
started?[R]
started_at[R]
store[R]
stores[R]
total[R]

Public Class Methods

add_store(name, store) click to toggle source
# File lib/progressrus.rb, line 49
def add_store(name, store)
  validate_store!(store)
  stores[name] = store
end
all(scope, store: :redis)
Alias for: scope
clear_stores() click to toggle source
# File lib/progressrus.rb, line 37
def clear_stores
  @stores = {}
end
find(scope, id, store: :redis) click to toggle source
# File lib/progressrus.rb, line 59
def find(scope, id, store: :redis)
  stores[store].find(scope, id)
end
flush(scope, id = nil, store: :redis) click to toggle source
# File lib/progressrus.rb, line 63
def flush(scope, id = nil, store: :redis)
  stores[store].flush(scope, id)
end
new(scope: "progressrus", total: nil, name: nil, id: SecureRandom.uuid, params: {}, stores: nil, completed_at: nil, started_at: nil, count: 0, failed_at: nil, error_count: 0, persist: false, expires_at: nil, persisted: false) click to toggle source
# File lib/progressrus.rb, line 86
def initialize(scope: "progressrus", total: nil, name: nil,
  id: SecureRandom.uuid, params: {}, stores: nil,
  completed_at: nil, started_at: nil, count: 0, failed_at: nil,
  error_count: 0, persist: false, expires_at: nil, persisted: false)

  raise ArgumentError, "Total cannot be negative." if total && total < 0

  @name         = name || id
  @scope        = Array(scope).map(&:to_s)
  @total        = total
  @id           = id
  @params       = params
  @stores       = extract_stores(stores)
  @count        = count
  @error_count  = error_count

  @started_at   = parse_time(started_at)
  @completed_at = parse_time(completed_at)
  @failed_at    = parse_time(failed_at)
  @expires_at   = parse_time(expires_at)
  @persisted    = persisted

  persist(force: true) if persist
end
scope(scope, store: :redis) click to toggle source
# File lib/progressrus.rb, line 54
def scope(scope, store: :redis)
  stores[store].scope(scope)
end
Also aliased as: all
stores() click to toggle source
# File lib/progressrus.rb, line 41
def stores
  mutex.synchronize do
    @stores ||= {
      redis: Store::Redis.new(::Redis.new(host: ENV["PROGRESSRUS_REDIS_HOST"] || "localhost"))
    }
  end
end

Private Class Methods

validate_store!(store) click to toggle source
# File lib/progressrus.rb, line 69
def validate_store!(store)
  valid = Store::Base.new.public_methods(false).all? do |method|
    store.respond_to?(method)
  end
  raise InvalidStoreError unless valid
end

Public Instance Methods

complete(now: Time.now) click to toggle source
# File lib/progressrus.rb, line 126
def complete(now: Time.now)
  @started_at ||= now
  @completed_at = now
  persist(force: true)
end
count=(new_count, **args) click to toggle source
# File lib/progressrus.rb, line 122
def count=(new_count, **args)
  tick(new_count - @count, *args)
end
elapsed(now: Time.now) click to toggle source
# File lib/progressrus.rb, line 176
def elapsed(now: Time.now)
  now - started_at
end
error(ticks = 1, now: Time.now) click to toggle source
# File lib/progressrus.rb, line 117
def error(ticks = 1, now: Time.now)
  @error_count ||= 0
  @error_count += ticks
end
eta(now: Time.now) click to toggle source
# File lib/progressrus.rb, line 190
def eta(now: Time.now)
  return if count.to_i == 0 || total.to_i == 0

  processed_per_second = (count.to_f / elapsed(now: now))
  left = (total - count)
  seconds_to_finished = left / processed_per_second
  now + seconds_to_finished
end
expired?(now: Time.now) click to toggle source
# File lib/progressrus.rb, line 199
def expired?(now: Time.now)
  expires_at && expires_at < now
end
fail(now: Time.now) click to toggle source
# File lib/progressrus.rb, line 147
def fail(now: Time.now)
  @started_at ||= now
  @failed_at = now
  persist(force: true)
end
flush() click to toggle source
# File lib/progressrus.rb, line 132
def flush
  stores.each_value { |store| store.flush(scope, id) }
end
percentage() click to toggle source
# File lib/progressrus.rb, line 180
def percentage
  return unless total

  if total > 0
    count.to_f / total
  else
    1.0
  end
end
persisted?() click to toggle source
# File lib/progressrus.rb, line 203
def persisted?
  @persisted
end
running?() click to toggle source
# File lib/progressrus.rb, line 143
def running?
  count > 0
end
status() click to toggle source
# File lib/progressrus.rb, line 136
def status
  return :completed if completed?
  return :failed if failed?
  return :running if running?
  :started
end
tick(ticks = 1, now: Time.now) click to toggle source
# File lib/progressrus.rb, line 111
def tick(ticks = 1, now: Time.now)
  @started_at ||= now if ticks >= 1
  @count += ticks
  persist
end
to_serializeable() click to toggle source
# File lib/progressrus.rb, line 153
def to_serializeable
  {
    name:         name,
    id:           id,
    scope:        scope,
    started_at:   started_at,
    completed_at: completed_at,
    failed_at:    failed_at,
    expires_at:   expires_at,
    count:        count,
    total:        total,
    params:       params,
    error_count:  error_count
  }
end
total=(new_total) click to toggle source
# File lib/progressrus.rb, line 169
def total=(new_total)
  raise ArgumentError, "Total cannot be negative." if new_total < 0
  @total = new_total
  persist(force: true) if persisted?
  @total
end

Private Instance Methods

extract_stores(stores) click to toggle source
# File lib/progressrus.rb, line 209
def extract_stores(stores)
  return Progressrus.stores unless stores

  Array(stores).each_with_object({}) do |store, hash|
    stored_found = Progressrus.stores[store]
    raise StoreNotFoundError, store unless stored_found

    hash[store] = stored_found
  end
end
parse_time(time) click to toggle source
# File lib/progressrus.rb, line 231
def parse_time(time)
  return Time.parse(time) if time.is_a?(String)
  time
end
persist(force: false) click to toggle source
# File lib/progressrus.rb, line 220
def persist(force: false)
  stores.each_value do |store|
    begin
      store.persist(self, force: force, expires_at: expires_at)
    rescue Progressrus::Store::BackendError
      # noop
    end
  end
  @persisted = true
end