Class: RRRSpec::Taskset

Inherits:
Object
  • Object
show all
Defined in:
lib/rrrspec/redis_models.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(taskset_key) ⇒ Taskset

Returns a new instance of Taskset.



144
145
146
 
# File 'lib/rrrspec/redis_models.rb', line 144

def initialize(taskset_key)
  @key = taskset_key
end

Instance Attribute Details

#key ⇒ Object (readonly)

Returns the value of attribute key.



142
143
144
 
# File 'lib/rrrspec/redis_models.rb', line 142

def key
  @key
end

Class Method Details

.create(rsync_name, setup_command, slave_command, worker_type, taskset_class, max_workers, max_trials, unknown_spec_timeout_sec, least_timeout_sec) ⇒ Object

Public: Create a new taskset. NOTE: This method will NOT call ActiveTaskset.add.



150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
 
# File 'lib/rrrspec/redis_models.rb', line 150

def self.create(rsync_name, setup_command, slave_command, worker_type,
                taskset_class, max_workers, max_trials,
                unknown_spec_timeout_sec, least_timeout_sec)
  now = Time.zone.now
  # For the reasons unknown, UUIDTools::UUID.timestamp_create changes 'now'.
  taskset_key = RRRSpec.make_key(
    'rrrspec', 'taskset', UUIDTools::UUID.timestamp_create(now.dup)
  )
  RRRSpec.redis.hmset(
    taskset_key,
    'rsync_name', rsync_name,
    'setup_command', setup_command,
    'slave_command', slave_command,
    'worker_type', worker_type,
    'max_workers', max_workers,
    'max_trials', max_trials,
    'taskset_class', taskset_class,
    'unknown_spec_timeout_sec', unknown_spec_timeout_sec.to_s,
    'least_timeout_sec', least_timeout_sec.to_s,
    'created_at', now.to_s,
  )
  return new(taskset_key)
end

Instance Method Details

#==(other) ⇒ Object 



174
175
176
 
# File 'lib/rrrspec/redis_models.rb', line 174

def ==(other)
  @key == other.key
end

#add_slave(slave) ⇒ Object

Public: Add a slave



284
285
286
287
 
# File 'lib/rrrspec/redis_models.rb', line 284

def add_slave(slave)
  RRRSpec.redis.rpush(RRRSpec.make_key(key, 'slave'),
                      slave.key)
end

#add_task(task) ⇒ Object

Public: Add a task. NOTE: This method does NOT enqueue to the task_queue



301
302
303
304
 
# File 'lib/rrrspec/redis_models.rb', line 301

def add_task(task)
  RRRSpec.redis.rpush(RRRSpec.make_key(key, 'tasks'), task.key)
  RRRSpec.redis.rpush(RRRSpec.make_key(key, 'tasks_left'), task.key)
end

#add_worker_log(worker_log) ⇒ Object

Public: Add a worker log



268
269
270
271
 
# File 'lib/rrrspec/redis_models.rb', line 268

def add_worker_log(worker_log)
  RRRSpec.redis.rpush(RRRSpec.make_key(key, 'worker_log'),
                      worker_log.key)
end

#append_log(string) ⇒ Object

Public: Append a line to the log



427
428
429
 
# File 'lib/rrrspec/redis_models.rb', line 427

def append_log(string)
  RRRSpec.redis.append(RRRSpec.make_key(key, 'log'), string)
end

#cancel ⇒ Object 



186
187
188
 
# File 'lib/rrrspec/redis_models.rb', line 186

def cancel
  ArbiterQueue.cancel(self)
end

#clear_queue ⇒ Object

Public: Remove all the tasks enqueued to the task_queue.



359
360
361
 
# File 'lib/rrrspec/redis_models.rb', line 359

def clear_queue
  RRRSpec.redis.del(RRRSpec.make_key(key, 'task_queue'))
end

#created_at ⇒ Object

Public: Returns the created_at

Returns Time



259
260
261
262
 
# File 'lib/rrrspec/redis_models.rb', line 259

def created_at
  v = RRRSpec.redis.hget(key, 'created_at')
  v.present? ? Time.zone.parse(v) : nil
end

#dequeue_task(timeout) ⇒ Object

Public: Dequeue the task from the task_queue.

Returns a task or nil if timeouts



348
349
350
351
352
353
354
355
356
 
# File 'lib/rrrspec/redis_models.rb', line 348

def dequeue_task(timeout)
  if timeout < 0
    task_key = RRRSpec.redis.lpop(RRRSpec.make_key(key, 'task_queue'))
  else
    _, task_key = RRRSpec.redis.blpop(RRRSpec.make_key(key, 'task_queue'), timeout)
  end
  return nil unless task_key
  Task.new(task_key)
end

#enqueue_task(task) ⇒ Object

Public: Enqueue the task to the task_queue.



336
337
338
 
# File 'lib/rrrspec/redis_models.rb', line 336

def enqueue_task(task)
  RRRSpec.redis.rpush(RRRSpec.make_key(key, 'task_queue'), task.key)
end

#exist? ⇒ Boolean

Returns:

  • (Boolean) 


178
179
180
 
# File 'lib/rrrspec/redis_models.rb', line 178

def exist?
  RRRSpec.redis.exists(key)
end

#expire(sec) ⇒ Object

Persistence



459
460
461
462
463
464
465
466
467
468
469
470
 
# File 'lib/rrrspec/redis_models.rb', line 459

def expire(sec)
  tasks.each { |task| task.expire(sec) }
  slaves.each { |slave| slave.expire(sec) }
  worker_logs.each { |worker_log| worker_log.expire(sec) }
  RRRSpec.redis.expire(key, sec)
  RRRSpec.redis.expire(RRRSpec.make_key(key, 'log'), sec)
  RRRSpec.redis.expire(RRRSpec.make_key(key, 'slave'), sec)
  RRRSpec.redis.expire(RRRSpec.make_key(key, 'worker_log'), sec)
  RRRSpec.redis.expire(RRRSpec.make_key(key, 'task_queue'), sec)
  RRRSpec.redis.expire(RRRSpec.make_key(key, 'tasks'), sec)
  RRRSpec.redis.expire(RRRSpec.make_key(key, 'tasks_left'), sec)
end

#failed_count ⇒ Object

Public: Current failed task count. A task is counted as failed one if its status is “failed”.

Returns a number



401
402
403
 
# File 'lib/rrrspec/redis_models.rb', line 401

def failed_count
  RRRSpec.redis.hget(key, 'failed_count').to_i
end

#finish_task(task) ⇒ Object

Public: Finish the task. It is no longer appeared in the ‘tasks_left`.



307
308
309
 
# File 'lib/rrrspec/redis_models.rb', line 307

def finish_task(task)
  RRRSpec.redis.lrem(RRRSpec.make_key(key, 'tasks_left'), 0, task.key)
end

#finished_at ⇒ Object

Public: Returns the finished_at



411
412
413
414
 
# File 'lib/rrrspec/redis_models.rb', line 411

def finished_at
  v = RRRSpec.redis.hget(key, 'finished_at')
  v.present? ? Time.zone.parse(v) : nil
end

#incr_failed_count ⇒ Object

Public: Increment failed_count



406
407
408
 
# File 'lib/rrrspec/redis_models.rb', line 406

def incr_failed_count
  RRRSpec.redis.hincrby(key, 'failed_count', 1)
end

#incr_succeeded_count ⇒ Object

Public: Increment succeeded_count



393
394
395
 
# File 'lib/rrrspec/redis_models.rb', line 393

def incr_succeeded_count
  RRRSpec.redis.hincrby(key, 'succeeded_count', 1)
end

#least_timeout_sec ⇒ Object

Public: Timeout sec at least any specs should wait.

Returns number



252
253
254
 
# File 'lib/rrrspec/redis_models.rb', line 252

def least_timeout_sec
  RRRSpec.redis.hget(key, 'least_timeout_sec').to_i
end

#log ⇒ Object

Public: Overall logs of the taskset



422
423
424
 
# File 'lib/rrrspec/redis_models.rb', line 422

def log
  RRRSpec.redis.get(RRRSpec.make_key(key, 'log')) || ""
end

#max_trials ⇒ Object

Public: The number of trials that should be made.

Returns number



231
232
233
 
# File 'lib/rrrspec/redis_models.rb', line 231

def max_trials
  RRRSpec.redis.hget(key, 'max_trials').to_i
end

#max_workers ⇒ Object

Public: The number of workers that is used to run the specs

Returns number



224
225
226
 
# File 'lib/rrrspec/redis_models.rb', line 224

def max_workers
  RRRSpec.redis.hget(key, 'max_workers').to_i
end

#persisted? ⇒ Boolean

Returns:

  • (Boolean) 


182
183
184
 
# File 'lib/rrrspec/redis_models.rb', line 182

def persisted?
  RRRSpec.redis.ttl(key) != -1
end

#queue_empty? ⇒ Boolean

Public: Checks whether the task_queue is empty.

Returns:

  • (Boolean) 


364
365
366
 
# File 'lib/rrrspec/redis_models.rb', line 364

def queue_empty?
  RRRSpec.redis.llen(RRRSpec.make_key(key, 'task_queue')) == 0
end

#reversed_enqueue_task(task) ⇒ Object

Public: Enqueue the task in the reversed way.



341
342
343
 
# File 'lib/rrrspec/redis_models.rb', line 341

def reversed_enqueue_task(task)
  RRRSpec.redis.lpush(RRRSpec.make_key(key, 'task_queue'), task.key)
end

#rsync_name ⇒ Object

Public: The path name that is used in rsync

Returns string



196
197
198
 
# File 'lib/rrrspec/redis_models.rb', line 196

def rsync_name
  RRRSpec.redis.hget(key, 'rsync_name')
end

#set_finished_time ⇒ Object

Public: Set finished_at time if it is empty



417
418
419
 
# File 'lib/rrrspec/redis_models.rb', line 417

def set_finished_time
  RRRSpec.redis.hsetnx(key, 'finished_at', Time.zone.now.to_s)
end

#setup_command ⇒ Object

Public: The command used in setup

Returns string



203
204
205
 
# File 'lib/rrrspec/redis_models.rb', line 203

def setup_command
  RRRSpec.redis.hget(key, 'setup_command')
end

#slave_command ⇒ Object

Public: The command that invokes rrrspec slave

Returns string



210
211
212
 
# File 'lib/rrrspec/redis_models.rb', line 210

def slave_command
  RRRSpec.redis.hget(key, 'slave_command')
end

#slaves ⇒ Object

Public: Return an array of slaves



290
291
292
293
294
 
# File 'lib/rrrspec/redis_models.rb', line 290

def slaves
  RRRSpec.redis.lrange(RRRSpec.make_key(key, 'slave'), 0, -1).map do |key|
    Slave.new(key)
  end
end

#status ⇒ Object

Public: Current status

Returns either nil, “running”, “succeeded”, “cancelled” or “failed”



374
375
376
 
# File 'lib/rrrspec/redis_models.rb', line 374

def status
  RRRSpec.redis.hget(key, 'status')
end

#succeeded_count ⇒ Object

Public: Current succeeded task count. A task is counted as succeeded one if its status is “passed” or “pending”.

Returns a number



388
389
390
 
# File 'lib/rrrspec/redis_models.rb', line 388

def succeeded_count
  RRRSpec.redis.hget(key, 'succeeded_count').to_i
end

#task_size ⇒ Object

Public: Size of all tasks.



321
322
323
 
# File 'lib/rrrspec/redis_models.rb', line 321

def task_size
  RRRSpec.redis.llen(RRRSpec.make_key(key, 'tasks')).to_i
end

#tasks ⇒ Object

Public: All the tasks that are contained by the taskset.

Returns an array of the task instances



314
315
316
317
318
 
# File 'lib/rrrspec/redis_models.rb', line 314

def tasks
  RRRSpec.redis.lrange(RRRSpec.make_key(key, 'tasks'), 0, -1).map do |key|
    Task.new(key)
  end
end

#tasks_left ⇒ Object

Public: All the tasks that are not migrated into the persistent store. In short, the tasks that are ‘add_task`ed but not `finish_task`ed.

Returns an array of the task instances.



329
330
331
332
333
 
# File 'lib/rrrspec/redis_models.rb', line 329

def tasks_left
  RRRSpec.redis.lrange(RRRSpec.make_key(key, 'tasks_left'), 0, -1).map do |key|
    Task.new(key)
  end
end

#taskset_class ⇒ Object

Public: A value that identifies the same taskset.

Returns string



238
239
240
 
# File 'lib/rrrspec/redis_models.rb', line 238

def taskset_class
  RRRSpec.redis.hget(key, 'taskset_class')
end

#to_h ⇒ Object

Serialize



434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
 
# File 'lib/rrrspec/redis_models.rb', line 434

def to_h
  h = RRRSpec.redis.hgetall(key)
  h['key'] = key
  h['log'] = log
  h['tasks'] = tasks.map { |task| { 'key' => task.key } }
  h['slaves'] = slaves.map { |slave| { 'key' => slave.key } }
  h['worker_logs'] = worker_logs.map { |worker_log| { 'key' => worker_log.key } }
  RRRSpec.convert_if_present(h, 'max_workers') { |v| v.to_i }
  RRRSpec.convert_if_present(h, 'max_trials') { |v| v.to_i }
  RRRSpec.convert_if_present(h, 'unknown_spec_timeout_sec') { |v| v.to_i }
  RRRSpec.convert_if_present(h, 'least_timeout_sec') { |v| v.to_i }
  RRRSpec.convert_if_present(h, 'created_at') { |v| Time.zone.parse(v) }
  RRRSpec.convert_if_present(h, 'finished_at') { |v| Time.zone.parse(v) }
  h.delete('succeeded_count')
  h.delete('failed_count')
  h
end

#to_json(options = nil) ⇒ Object 



452
453
454
 
# File 'lib/rrrspec/redis_models.rb', line 452

def to_json(options=nil)
  to_h.to_json(options)
end

#unknown_spec_timeout_sec ⇒ Object

Public: The timeout sec for unknown spec files.

Returns number



245
246
247
 
# File 'lib/rrrspec/redis_models.rb', line 245

def unknown_spec_timeout_sec
  RRRSpec.redis.hget(key, 'unknown_spec_timeout_sec').to_i
end

#update_status(status) ⇒ Object

Public: Update the status. It should be one of:

“running”, “succeeded”, “cancelled”, “failed” 


380
381
382
 
# File 'lib/rrrspec/redis_models.rb', line 380

def update_status(status)
  RRRSpec.redis.hset(key, 'status', status)
end

#worker_logs ⇒ Object

Public: Return an array of worker_logs



274
275
276
277
278
 
# File 'lib/rrrspec/redis_models.rb', line 274

def worker_logs
  RRRSpec.redis.lrange(RRRSpec.make_key(key, 'worker_log'), 0, -1).map do |key|
    WorkerLog.new(key)
  end
end

#worker_type ⇒ Object

Public: Type of the worker required to run the specs

Returns string



217
218
219
 
# File 'lib/rrrspec/redis_models.rb', line 217

def worker_type
  RRRSpec.redis.hget(key, 'worker_type')
end