Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
92 changes: 67 additions & 25 deletions app/models/reminder_mail.rb
Original file line number Diff line number Diff line change
@@ -1,53 +1,95 @@
class ReminderMail < ApplicationRecord
SMTP_MAX_RETRIES = 5

# Longest wait for a server-requested retry. Longer blocks (e.g., the
# provider's daily quota) end the run instead, and it resumes the next day
SMTP_MAX_WAIT = 15.minutes

# Reminders sent per run (the task runs daily), leaving room in the SMTP
# provider's daily quota for regular notifications
DAILY_LIMIT = 40

class << self
def register_reminder
users =
User.joins(:registers)
.where(registers: { notified: false })
.distinct!

users.each do |user|
registers =
user.registers.select do |register|
!register.validated? && (register.updated_at < 1.month.ago) && (
!register.submitted? ||
(!register.notified? && register.all_endorsed?)
)
end

unless registers.empty?
deliver_with_retry(
AdminMailer.with(user: user, registers: registers)
.register_reminder_email
)
sleep 2 # Stay under the SMTP provider's recipient rate limit
##
# Remind users with pending registers, at most once a month per user and
# up to +limit+ users per run, oldest reminders first. Returns the number
# of reminders sent
def register_reminder(limit: DAILY_LIMIT)
sent = 0
due_users.each do |user|
break if sent >= limit

registers = pending_registers(user)
next if registers.empty? || !user.opt_notification?

message =
AdminMailer.with(user: user, registers: registers)
.register_reminder_email
unless deliver_with_retry(message)
$stderr.puts "Stopped after #{sent} reminders: #{@stop_reason}"
break
end

user.update_column(:register_reminder_at, Time.current)
sent += 1
sleep 2 # Stay under the SMTP provider's recipient rate limit
end
sent
end

private

# Retry deliveries temporarily rejected by the SMTP server (421),
# waiting until the time the server asks for
def due_users
User.joins(:registers)
.where(registers: { notified: false })
.where(
'users.register_reminder_at IS NULL OR ' \
'users.register_reminder_at < ?', 1.month.ago
)
.distinct
.order(Arel.sql('users.register_reminder_at ASC NULLS FIRST'), :id)
end

def pending_registers(user)
user.registers.select do |register|
!register.validated? && (register.updated_at < 1.month.ago) && (
!register.submitted? ||
(!register.notified? && register.all_endorsed?)
)
end
end

##
# Deliver +message+, retrying when the SMTP server temporarily rejects it
# (421) and asks to wait no longer than +SMTP_MAX_WAIT+. Returns +false+
# (with the reason in +@stop_reason+) if the server asks to wait longer
def deliver_with_retry(message)
attempts = 0
begin
message.deliver_now
true
rescue Net::SMTPServerBusy => e
attempts += 1
raise if attempts > SMTP_MAX_RETRIES

sleep(smtp_retry_delay(e.message))
delay = smtp_retry_delay(e.message)
if delay > SMTP_MAX_WAIT
@stop_reason = e.message.strip
return false
end

sleep(delay)
retry
end
end

##
# Seconds to wait before retrying, as requested by the server's
# "try again after <time>" message (60 if no time is given)
def smtp_retry_delay(error_message)
if error_message =~ /try again after (.+?)\s*\z/
retry_at = Time.parse($1) rescue nil
return (retry_at - Time.now).ceil.clamp(1, 900) if retry_at
return [(retry_at - Time.now).ceil, 1].max if retry_at
end
60
end
Expand Down
4 changes: 3 additions & 1 deletion config/schedule.rb
Original file line number Diff line number Diff line change
Expand Up @@ -14,14 +14,16 @@
every 1.day do
rake 'works:update names:find parents:infer'
rake 'wikidata:push'
# Sends up to ReminderMail::DAILY_LIMIT reminders a day, each user at most
# once a month, to stay within the SMTP provider's daily quota
runner 'ReminderMail.register_reminder'
end

every 1.week do
rake 'sitemap:refresh:no_ping'
end

every 1.month do
runner 'ReminderMail.register_reminder'
rake 'genomes:clean'
rake 'strains:clean'
end
Expand Down
Original file line number Diff line number Diff line change
@@ -0,0 +1,7 @@
class AddRegisterReminderAtToUsers < ActiveRecord::Migration[6.1]
def change
# Last time the user was sent a register reminder, so reminders can be
# spread over several days without sending anyone a duplicate
add_column :users, :register_reminder_at, :datetime, default: nil
end
end
3 changes: 2 additions & 1 deletion db/schema.rb
Original file line number Diff line number Diff line change
Expand Up @@ -10,7 +10,7 @@
#
# It's strongly recommended that you check this file into your version control system.

ActiveRecord::Schema.define(version: 2026_11_09_120000) do
ActiveRecord::Schema.define(version: 2026_11_10_100000) do

# These are extensions that must be enabled in order to support this database
enable_extension "fuzzystrmatch"
Expand Down Expand Up @@ -598,6 +598,7 @@
t.date "community_member_started_on"
t.date "community_member_expires_on"
t.boolean "officer", default: false
t.datetime "register_reminder_at"
t.index ["confirmation_token"], name: "index_users_on_confirmation_token", unique: true
t.index ["email"], name: "index_users_on_email", unique: true
t.index ["reset_password_token"], name: "index_users_on_reset_password_token", unique: true
Expand Down
128 changes: 128 additions & 0 deletions test/models/reminder_mail_test.rb
Original file line number Diff line number Diff line change
@@ -0,0 +1,128 @@
require 'test_helper'
require 'minitest/mock'
require 'net/smtp'

class ReminderMailTest < ActiveSupport::TestCase
# Test delivery method that rejects the first +failures+ messages with a 421
# response asking to retry after +retry_in+ seconds
class BusyDelivery
class << self
attr_accessor :failures, :retry_in
end

def initialize(_settings); end

def deliver!(mail)
if self.class.failures.positive?
self.class.failures -= 1
retry_at = (Time.now + self.class.retry_in).utc.strftime('%a, %d %b %Y %H:%M:%S UTC')
raise Net::SMTPServerBusy.new(Net::SMTP::Response.parse(
"421 Domain seqco.de is not allowed to send: limit exceeded, try again after #{retry_at}\n"
))
end
ActionMailer::Base.deliveries << mail
end
end
ActionMailer::Base.add_delivery_method(:busy, BusyDelivery)

setup do
ActionMailer::Base.deliveries.clear
# Every register in the fixtures is a month-old pending register
Register.update_all(updated_at: 2.months.ago)

@contributor = users(:contributor)
@curator = users(:curator)
registers(:draft).dup.tap do |r|
r.accession = 'r:draft02'
r.user = @curator
r.save!(validate: false)
end
Register.update_all(updated_at: 2.months.ago)

@sleeps = []
end

teardown do
ActionMailer::Base.delivery_method = :test
end

def run_reminders(**opts)
sent = nil
_out, @err = capture_io do
ReminderMail.stub(:sleep, ->(s) { @sleeps << s }) do
sent = ReminderMail.register_reminder(**opts)
end
end
sent
end

def recipients
ActionMailer::Base.deliveries.flat_map(&:to)
end

test 'reminds users with pending registers and records when' do
assert_equal 2, run_reminders

assert_equal [@contributor.email, @curator.email].sort, recipients.sort
assert_not_nil @contributor.reload.register_reminder_at
assert_not_nil @curator.reload.register_reminder_at
end

test 'does not remind users again within a month' do
@contributor.update_column(:register_reminder_at, 1.week.ago)

assert_equal 1, run_reminders
assert_equal [@curator.email], recipients
end

test 'reminds users again after a month' do
@contributor.update_column(:register_reminder_at, 5.weeks.ago)
@curator.update_column(:register_reminder_at, 1.week.ago)

assert_equal 1, run_reminders
assert_equal [@contributor.email], recipients
end

test 'sends at most the daily limit, users never reminded first' do
@contributor.update_column(:register_reminder_at, 2.months.ago)

assert_equal 1, run_reminders(limit: 1)
assert_equal [@curator.email], recipients

# The next run picks up where the previous one stopped
ActionMailer::Base.deliveries.clear
assert_equal 1, run_reminders(limit: 1)
assert_equal [@contributor.email], recipients
end

test 'skips users who opted out of notifications without counting them' do
@contributor.update_column(:opt_notification, false)

assert_equal 1, run_reminders(limit: 1)
assert_equal [@curator.email], recipients
assert_nil @contributor.reload.register_reminder_at
end

test 'waits and retries when the server asks for a short wait' do
ActionMailer::Base.delivery_method = :busy
BusyDelivery.failures = 1
BusyDelivery.retry_in = 6

assert_equal 2, run_reminders
assert_equal 2, recipients.size
assert(@sleeps.any? { |s| s.between?(5, 7) }, "slept #{@sleeps}")
end

test 'stops until the next run when the server asks for a long wait' do
ActionMailer::Base.delivery_method = :busy
BusyDelivery.failures = 1
BusyDelivery.retry_in = 9.hours.to_i

assert_equal 0, run_reminders
assert_empty recipients
assert_nil @contributor.reload.register_reminder_at
assert_nil @curator.reload.register_reminder_at
assert_empty @sleeps
assert_match(/Stopped after 0 reminders: 421 .*limit exceeded/, @err)
end
end
Loading