Class: SolidQueueTui::Data::JobsQuery

Inherits:
Object
  • Object
show all
Defined in:
lib/solid_queue_tui/data/jobs_query.rb

Defined Under Namespace

Classes: Job

Class Method Summary collapse

Class Method Details

.count(status:, filter: nil, queue: nil) ⇒ Object 



27
28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/solid_queue_tui/data/jobs_query.rb', line 27

def self.count(status:, filter: nil, queue: nil)
  case status
  when "pending"   then count_pending(queue: queue, filter: filter)
  when "claimed"   then count_scope(SolidQueue::ClaimedExecution.joins(:job), filter: filter, queue: queue)
  when "blocked"   then count_scope(SolidQueue::BlockedExecution.joins(:job), filter: filter, queue: queue)
  when "scheduled" then count_scope(SolidQueue::ScheduledExecution.joins(:job), filter: filter, queue: queue)
  when "completed" then count_finished(filter: filter, queue: queue)
  else 0
  end
rescue => e
  0
end

.count_pending(queue:, filter: nil) ⇒ Object 



62
63
64
65
66
67
 
# File 'lib/solid_queue_tui/data/jobs_query.rb', line 62

def self.count_pending(queue:, filter: nil)
  scope = SolidQueue::ReadyExecution.joins(:job)
  scope = scope.where(queue_name: queue) if queue
  scope = apply_class_name_filter(scope, filter)
  scope.count
end

.fetch(status:, filter: nil, queue: nil, limit: 100, offset: 0) ⇒ Object 



14
15
16
17
18
19
20
21
22
23
24
25
 
# File 'lib/solid_queue_tui/data/jobs_query.rb', line 14

def self.fetch(status:, filter: nil, queue: nil, limit: 100, offset: 0)
  case status
  when "pending"   then fetch_pending(queue: queue, filter: filter, limit: limit, offset: offset)
  when "claimed"   then fetch_claimed(filter: filter, queue: queue, limit: limit, offset: offset)
  when "blocked"   then fetch_blocked(filter: filter, queue: queue, limit: limit, offset: offset)
  when "scheduled" then fetch_scheduled(filter: filter, queue: queue, limit: limit, offset: offset)
  when "completed" then fetch_finished(filter: filter, queue: queue, limit: limit, offset: offset)
  else []
  end
rescue => e
  []
end

.fetch_blocked(filter: nil, queue: nil, limit: 100, offset: 0) ⇒ Object 



92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/solid_queue_tui/data/jobs_query.rb', line 92

def self.fetch_blocked(filter: nil, queue: nil, limit: 100, offset: 0)
  scope = SolidQueue::BlockedExecution.joins(:job)
  scope = scope.merge(SolidQueue::Job.where(queue_name: queue)) if queue
  scope = apply_class_name_filter(scope, filter)
  scope = scope.order(job_id: :asc).offset(offset).limit(limit)

  scope.includes(:job).map do |be|
    job = be.job
    Job.new(
      id: job.id,
      queue_name: job.queue_name,
      class_name: job.class_name,
      priority: job.priority,
      status: "blocked",
      active_job_id: job.active_job_id,
      concurrency_key: job.concurrency_key,
      created_at: be.created_at,
      expires_at: be.expires_at
    )
  end
end

.fetch_claimed(filter: nil, queue: nil, limit: 100, offset: 0) ⇒ Object 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/solid_queue_tui/data/jobs_query.rb', line 69

def self.fetch_claimed(filter: nil, queue: nil, limit: 100, offset: 0)
  scope = SolidQueue::ClaimedExecution.joins(:job)
  scope = scope.merge(SolidQueue::Job.where(queue_name: queue)) if queue
  scope = apply_class_name_filter(scope, filter)
  scope = scope.order(job_id: :asc).offset(offset).limit(limit)

  scope.includes(:job).map do |ce|
    job = ce.job
    Job.new(
      id: job.id,
      queue_name: job.queue_name,
      class_name: job.class_name,
      priority: job.priority,
      status: "claimed",
      active_job_id: job.active_job_id,
      concurrency_key: job.concurrency_key,
      created_at: job.created_at,
      worker_id: ce.process_id,
      started_at: ce.created_at
    )
  end
end

.fetch_finished(filter: nil, queue: nil, limit: 100, offset: 0) ⇒ Object 



136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
 
# File 'lib/solid_queue_tui/data/jobs_query.rb', line 136

def self.fetch_finished(filter: nil, queue: nil, limit: 100, offset: 0)
  scope = SolidQueue::Job.finished
  scope = scope.where(queue_name: queue) if queue
  scope = scope.where("class_name LIKE ?", "%#{filter}%") if filter.present?
  scope = scope.order(finished_at: :desc).offset(offset).limit(limit)

  scope.map do |job|
    Job.new(
      id: job.id,
      queue_name: job.queue_name,
      class_name: job.class_name,
      priority: job.priority,
      status: "completed",
      active_job_id: job.active_job_id,
      arguments: job.arguments,
      finished_at: job.finished_at,
      created_at: job.created_at
    )
  end
end

.fetch_pending(queue:, filter: nil, limit: 100, offset: 0) ⇒ Object 



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/solid_queue_tui/data/jobs_query.rb', line 40

def self.fetch_pending(queue:, filter: nil, limit: 100, offset: 0)
  scope = SolidQueue::ReadyExecution.joins(:job)
  scope = scope.where(queue_name: queue) if queue
  scope = apply_class_name_filter(scope, filter)
  scope = scope.order(priority: :asc, job_id: :asc).offset(offset).limit(limit)

  scope.includes(:job).map do |re|
    job = re.job
    Job.new(
      id: job.id,
      queue_name: job.queue_name,
      class_name: job.class_name,
      priority: job.priority,
      status: "pending",
      active_job_id: job.active_job_id,
      arguments: job.arguments,
      scheduled_at: job.scheduled_at,
      created_at: job.created_at
    )
  end
end

.fetch_scheduled(filter: nil, queue: nil, limit: 100, offset: 0) ⇒ Object 



114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
 
# File 'lib/solid_queue_tui/data/jobs_query.rb', line 114

def self.fetch_scheduled(filter: nil, queue: nil, limit: 100, offset: 0)
  scope = SolidQueue::ScheduledExecution.joins(:job)
  scope = scope.merge(SolidQueue::Job.where(queue_name: queue)) if queue
  scope = apply_class_name_filter(scope, filter)
  scope = scope.order(scheduled_at: :asc, priority: :asc).offset(offset).limit(limit)

  scope.includes(:job).map do |se|
    job = se.job
    Job.new(
      id: job.id,
      queue_name: job.queue_name,
      class_name: job.class_name,
      priority: job.priority,
      status: "scheduled",
      active_job_id: job.active_job_id,
      arguments: job.arguments,
      scheduled_at: se.scheduled_at,
      created_at: job.created_at
    )
  end
end