Class: RogIQ::Commands::Queue

Inherits:
Base
  • Object
show all
Defined in:
lib/rogiq/commands/queue.rb

Instance Method Summary collapse

Instance Method Details

#drain ⇒ Object 



96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/rogiq/commands/queue.rb', line 96

def drain
  RogIQ.load_rails!
  unless fmt.confirm!("Clear ready, scheduled, and blocked executions?", yes: options[:yes])
    fmt.warn_msg("Aborted.")
    return
  end

  Rails.application.load_tasks
  Rake::Task["queue:drain"].invoke
  fmt.success("Drain complete.")
end

#flush ⇒ Object 



33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/rogiq/commands/queue.rb', line 33

def flush
  RogIQ.load_rails!
  scope = SolidQueue::FailedExecution.joins(:job)
  scope = scope.where(solid_queue_jobs: { class_name: options[:class] }) if options[:class].present?

  n = scope.count
  if n.zero?
    fmt.success("No failed executions to discard.")
    return
  end

  unless fmt.confirm!("Discard #{n} failed execution(s)?", yes: options[:yes])
    fmt.warn_msg("Aborted.")
    return
  end

  discarded = 0
  scope.find_each do |fe|
    fe.discard
    discarded += 1
  end
  fmt.success("Discarded #{discarded} failed execution(s).")
end

#pause(queue_name) ⇒ Object 



81
82
83
84
85
 
# File 'lib/rogiq/commands/queue.rb', line 81

def pause(queue_name)
  RogIQ.load_rails!
  SolidQueue::Queue.find_by_name(queue_name).pause
  fmt.success("Paused queue #{queue_name}")
end

#resume(queue_name) ⇒ Object 



88
89
90
91
92
 
# File 'lib/rogiq/commands/queue.rb', line 88

def resume(queue_name)
  RogIQ.load_rails!
  SolidQueue::Queue.find_by_name(queue_name).resume
  fmt.success("Resumed queue #{queue_name}")
end

#retry_all ⇒ Object 



61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/rogiq/commands/queue.rb', line 61

def retry_all
  RogIQ.load_rails!
  scope = SolidQueue::FailedExecution.joins(:job)
  scope = scope.where(solid_queue_jobs: { class_name: options[:class] }) if options[:class].present?
  jobs = scope.includes(:job).map(&:job).uniq
  if jobs.empty?
    fmt.success("Nothing to retry.")
    return
  end

  unless fmt.confirm!("Retry #{jobs.size} failed job(s)?", yes: options[:yes])
    fmt.warn_msg("Aborted.")
    return
  end

  SolidQueue::FailedExecution.retry_all(jobs)
  fmt.success("Retried #{jobs.size} job(s).")
end

#stats ⇒ Object 



8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
# File 'lib/rogiq/commands/queue.rb', line 8

def stats
  RogIQ.load_rails!
  unless solid_queue_tables?
    fmt.error_msg("solid_queue tables not present")
    exit 1
  end

  if options[:by_class]
    rows = SolidQueue::Job.where(finished_at: nil).group(:class_name).count.sort_by { |_, n| -n }
    fmt.output(headers: %w[class_name unfinished_jobs], rows: rows.to_a)
  else
    payload = {
      ready: SolidQueue::ReadyExecution.count,
      scheduled: SolidQueue::ScheduledExecution.count,
      failed: SolidQueue::FailedExecution.count,
      claimed: SolidQueue::ClaimedExecution.count,
      blocked: defined?(SolidQueue::BlockedExecution) ? SolidQueue::BlockedExecution.count : nil
    }.compact
    fmt.output(payload)
  end
end