Class: Rpush::Daemon::Store::Redis

Inherits:
Object
  • Object
show all
Defined in:
lib/rpush/daemon/store/redis.rb

Constant Summary collapse

DEFAULT_MARK_OPTIONS = 
{ persist: true }

Instance Method Summary collapse

Instance Method Details

#all_apps ⇒ Object 



11
12
13
 
# File 'lib/rpush/daemon/store/redis.rb', line 11

def all_apps
  Rpush::Client::Redis::App.all
end

#app(app_id) ⇒ Object 



7
8
9
 
# File 'lib/rpush/daemon/store/redis.rb', line 7

def app(app_id)
  Rpush::Client::Redis::App.find(app_id)
end

#create_adm_notification(attrs, data, registration_ids, deliver_after, app) ⇒ Object 



90
91
92
93
 
# File 'lib/rpush/daemon/store/redis.rb', line 90

def create_adm_notification(attrs, data, registration_ids, deliver_after, app)
  notification = Rpush::Client::Redis::Adm::Notification.new
  create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app)
end

#create_apns_feedback(failed_at, device_token, app) ⇒ Object 



81
82
83
 
# File 'lib/rpush/daemon/store/redis.rb', line 81

def create_apns_feedback(failed_at, device_token, app)
  Rpush::Client::Redis::Apns::Feedback.create!(failed_at: failed_at, device_token: device_token, app_id: app.id)
end

#create_gcm_notification(attrs, data, registration_ids, deliver_after, app) ⇒ Object 



85
86
87
88
 
# File 'lib/rpush/daemon/store/redis.rb', line 85

def create_gcm_notification(attrs, data, registration_ids, deliver_after, app)
  notification = Rpush::Client::Redis::Gcm::Notification.new
  create_gcm_like_notification(notification, attrs, data, registration_ids, deliver_after, app)
end

#deliverable_notifications(limit) ⇒ Object 



15
16
17
18
19
20
21
 
# File 'lib/rpush/daemon/store/redis.rb', line 15

def deliverable_notifications(limit)
  retryable_ids = retryable_notification_ids
  limit -= retryable_ids.size
  pending_ids = limit > 0 ? pending_notification_ids(limit) : []
  ids = retryable_ids + pending_ids
  ids.map { |id| Rpush::Client::Redis::Notification.find(id) }
end

#mark_batch_delivered(notifications) ⇒ Object 



30
31
32
33
 
# File 'lib/rpush/daemon/store/redis.rb', line 30

def mark_batch_delivered(notifications)
  now = Time.now
  notifications.each { |n| mark_delivered(n, now) }
end

#mark_batch_failed(notifications, code, description) ⇒ Object 



46
47
48
49
 
# File 'lib/rpush/daemon/store/redis.rb', line 46

def mark_batch_failed(notifications, code, description)
  now = Time.now
  notifications.each { |n| mark_failed(n, code, description, now) }
end

#mark_batch_retryable(notifications, deliver_after) ⇒ Object 



73
74
75
 
# File 'lib/rpush/daemon/store/redis.rb', line 73

def mark_batch_retryable(notifications, deliver_after)
  notifications.each { |n| mark_retryable(n, deliver_after) }
end

#mark_delivered(notification, time, opts = {}) ⇒ Object 



23
24
25
26
27
28
 
# File 'lib/rpush/daemon/store/redis.rb', line 23

def mark_delivered(notification, time, opts = {})
  opts = DEFAULT_MARK_OPTIONS.dup.merge(opts)
  notification.delivered = true
  notification.delivered_at = time
  notification.save!(validate: false) if opts[:persist]
end

#mark_failed(notification, code, description, time, opts = {}) ⇒ Object 



35
36
37
38
39
40
41
42
43
44
 
# File 'lib/rpush/daemon/store/redis.rb', line 35

def mark_failed(notification, code, description, time, opts = {})
  opts = DEFAULT_MARK_OPTIONS.dup.merge(opts)
  notification.delivered = false
  notification.delivered_at = nil
  notification.failed = true
  notification.failed_at = time
  notification.error_code = code
  notification.error_description = description
  notification.save!(validate: false) if opts[:persist]
end

#mark_ids_failed(ids, code, description, time) ⇒ Object 



51
52
53
 
# File 'lib/rpush/daemon/store/redis.rb', line 51

def mark_ids_failed(ids, code, description, time)
  ids.each { |id| mark_failed(Rpush::Client::Redis::Notification.find(id), code, description, time) }
end

#mark_ids_retryable(ids, deliver_after) ⇒ Object 



77
78
79
 
# File 'lib/rpush/daemon/store/redis.rb', line 77

def mark_ids_retryable(ids, deliver_after)
  ids.each { |id| mark_retryable(Rpush::Client::Redis::Notification.find(id), deliver_after) }
end

#mark_retryable(notification, deliver_after, opts = {}) ⇒ Object 



55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/rpush/daemon/store/redis.rb', line 55

def mark_retryable(notification, deliver_after, opts = {})
  opts = DEFAULT_MARK_OPTIONS.dup.merge(opts)
  notification.delivered = false
  notification.delivered_at = nil
  notification.failed = false
  notification.failed_at = nil
  notification.retries += 1
  notification.deliver_after = deliver_after

  return unless opts[:persist]

  notification.save!(validate: false)
  namespace = Rpush::Client::Redis::Notification.absolute_retryable_namespace
  Modis.with_connection do |redis|
    redis.zadd(namespace, deliver_after.to_i, notification.id)
  end
end

#pending_delivery_count ⇒ Object 



109
110
111
112
113
114
115
116
 
# File 'lib/rpush/daemon/store/redis.rb', line 109

def pending_delivery_count
  Modis.with_connection do |redis|
    pending = redis.zrange(Rpush::Client::Redis::Notification.absolute_pending_namespace, 0, -1)
    retryable = redis.zrangebyscore(Rpush::Client::Redis::Notification.absolute_retryable_namespace, 0, Time.now.to_i)

    pending.count + retryable.count
  end
end

#release_connection ⇒ Object 



103
104
 
# File 'lib/rpush/daemon/store/redis.rb', line 103

def release_connection
end

#reopen_log ⇒ Object 



106
107
 
# File 'lib/rpush/daemon/store/redis.rb', line 106

def reopen_log
end

#translate_integer_notification_id(id) ⇒ Object 



118
119
120
 
# File 'lib/rpush/daemon/store/redis.rb', line 118

def translate_integer_notification_id(id)
  id
end

#update_app(app) ⇒ Object 



95
96
97
 
# File 'lib/rpush/daemon/store/redis.rb', line 95

def update_app(app)
  app.save!
end

#update_notification(notification) ⇒ Object 



99
100
101
 
# File 'lib/rpush/daemon/store/redis.rb', line 99

def update_notification(notification)
  notification.save!
end