Class: Sidekiq::Client

Inherits:
Object
  • Object
show all
Defined in:
lib/sidekiq/client.rb,
lib/sidekiq/testing.rb,
lib/sidekiq/testing/inline.rb

Class Method Summary collapse

Class Method Details

.default_middleware ⇒ Object 



9
10
11
12
 
# File 'lib/sidekiq/client.rb', line 9

def default_middleware
  Middleware::Chain.new do
  end
end

.enqueue(klass, *args) ⇒ Object

Resque compatibility helpers.

Example usage:

Sidekiq::Client.enqueue(MyWorker, 'foo', 1, :bat => 'bar')

Messages are enqueued to the ‘default’ queue.



80
81
82
 
# File 'lib/sidekiq/client.rb', line 80

def enqueue(klass, *args)
  klass.client_push('class' => klass, 'args' => args)
end

.enqueue_to(queue, klass, *args) ⇒ Object

Example usage:

Sidekiq::Client.enqueue_to(:queue_name, MyWorker, 'foo', 1, :bat => 'bar')



87
88
89
 
# File 'lib/sidekiq/client.rb', line 87

def enqueue_to(queue, klass, *args)
  klass.client_push('queue' => queue, 'class' => klass, 'args' => args)
end

.push(item) ⇒ Object

The main method used to push a job to Redis. Accepts a number of options:

queue - the named queue to use, default 'default'
class - the worker class to call, required
args - an array of simple arguments to the perform method, must be JSON-serializable
retry - whether to retry this job if it fails, true or false, default true
backtrace - whether to save any error backtrace, default false

All options must be strings, not symbols. NB: because we are serializing to JSON, all symbols in ‘args’ will be converted to strings.

Returns nil if not pushed to Redis or a unique Job ID if pushed.

Example:

Sidekiq::Client.push('queue' => 'my_queue', 'class' => MyWorker, 'args' => ['foo', 1, :bat => 'bar'])



39
40
41
42
43
44
45
46
 
# File 'lib/sidekiq/client.rb', line 39

def push(item)
  normed = normalize_item(item)
  payload = process_single(item['class'], normed)

  pushed = false
  pushed = raw_push([payload]) if payload
  pushed ? payload['jid'] : nil
end

.push_bulk(items) ⇒ Object

Push a large number of jobs to Redis. In practice this method is only useful if you are pushing tens of thousands of jobs or more. This method basically cuts down on the redis round trip latency.

Takes the same arguments as Client.push except that args is expected to be an Array of Arrays. All other keys are duplicated for each job. Each job is run through the client middleware pipeline and each job gets its own Job ID as normal.

Returns the number of jobs pushed or nil if the pushed failed. The number of jobs pushed can be less than the number given if the middleware stopped processing for one or more jobs.



61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/sidekiq/client.rb', line 61

def push_bulk(items)
  normed = normalize_item(items)
  payloads = items['args'].map do |args|
    raise ArgumentError, "Bulk arguments must be an Array of Arrays: [[1], [2]]" if !args.is_a?(Array)
    process_single(items['class'], normed.merge('args' => args, 'jid' => SecureRandom.hex(12)))
  end.compact

  pushed = false
  pushed = raw_push(payloads) if !payloads.empty?
  pushed ? payloads.size : nil
end

.raw_push(payloads) ⇒ Object 



93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/sidekiq/client.rb', line 93

def raw_push(payloads)
  pushed = false
  Sidekiq.redis do |conn|
    if payloads.first['at']
      pushed = conn.zadd('schedule', payloads.map {|hash| [hash['at'].to_s, Sidekiq.dump_json(hash)]})
    else
      q = payloads.first['queue']
      to_push = payloads.map { |entry| Sidekiq.dump_json(entry) }
      _, pushed = conn.multi do
        conn.sadd('queues', q)
        conn.lpush("queue:#{q}", to_push)
      end
    end
  end
  pushed
end

.raw_push_old ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
# File 'lib/sidekiq/testing.rb', line 5

def raw_push(payloads)
  pushed = false
  Sidekiq.redis do |conn|
    if payloads.first['at']
      pushed = conn.zadd('schedule', payloads.map {|hash| [hash['at'].to_s, Sidekiq.dump_json(hash)]})
    else
      q = payloads.first['queue']
      to_push = payloads.map { |entry| Sidekiq.dump_json(entry) }
      _, pushed = conn.multi do
        conn.sadd('queues', q)
        conn.lpush("queue:#{q}", to_push)
      end
    end
  end
  pushed
end

.registered_queues ⇒ Object 



18
19
20
 
# File 'lib/sidekiq/client.rb', line 18

def registered_queues
  Sidekiq.redis { |x| x.smembers('queues') }
end

.registered_workers ⇒ Object 



14
15
16
 
# File 'lib/sidekiq/client.rb', line 14

def registered_workers
  Sidekiq.redis { |x| x.smembers('workers') }
end