How can I schedule code to run every few hours in Elixir or Phoenix framework?
So let’s say I want to send a bunch of emails or recreate sitemap or whatever every 4 hours, how would I do that in Phoenix or just with Elixir?
I recommend you to make a small GenServer that you put in your app’s supervision tree – so it stays alive for as long as the app is live – and have it do something like this:
defmodule PeriodicWorker do
use GenServer
@impl true
def init(period_in_millis) do
# The `{:continue, :init}` tuple here instructs OTP to run `handle_continue`
# which in this case will fire the first `:do_stuff` message so the worker
# does its job once and then schedules itself to run again in the future.
# Without this you'd have to manually fire the message to the worker
# when your app starts.
{:ok, period_in_millis, {:continue, :init}}
end
def handle_continue(:init, period_in_millis) do
GenServer.call(self(), {:do_stuff, period_in_millis})
end
@impl true
def handle_call(:do_stuff, _caller_pid, period_in_millis) do
do_the_thing_you_need_done_periodically_here()
schedule_next_do_stuff(period_in_millis)
# or change `:ok` to the return value of the function that does the real work.
{:reply, :ok}
end
def schedule_next_do_stuff(period_in_millis) do
Process.send_after(self(), :do_stuff, period_in_millis)
end
end
You can then supervise it like this in your app:
defmodule YourApp do
use Application
def start(_type, _args) d
children = [
{PeriodicWorker, 4 * 60 * 60 * 1000}, # 4 hours
# ... other children ....
]
options = [strategy: :one_for_one, name: YourApp.Supervisor]
Supervisor.start_link(children, options)
end
end
Not tested but I’ve done this a number of times and it should match reality closely enough.
6 Likes
It depends how accurate you want it to be. If that release is restarted when the timer is a 1min then it’s going to be 1min between those two jobs. You could persist last_executed_at and use that to determine the initial delay.
Oban is a library option.
1 Like
Here’s a site I found that mentions 3 ways to get it done:
The first approach is GenServer which @dimitarvp mentioned.
If your requirements are not complex, you don’t need instrumentation and are not running in distributed mode, then you don’t need anything more.
But if you would like something more, checkout: Oban Git & Documentation
Oban: Robust job processing in Elixir, backed by modern PostgreSQL. Reliable,
observable and loaded with enterprise grade features.
5 Likes
Here’s a concrete example, so you can copy and learn from it.
Clone the Plausible Analytics repo, and search by Oban.Worker, you will see tons of example!!
Some Excerpts:
for site <- sites do
SendEmailReport.new(%{site_id: site.id, interval: "weekly"},
scheduled_at: monday_9am(site.timezone)
)
|> Oban.insert!()
end
def monday_9am(timezone) do
Timex.now(timezone)
|> Timex.shift(weeks: 1)
|> Timex.beginning_of_week()
|> Timex.shift(hours: 9)
end
OR
for site <- sites do
SendEmailReport.new(%{site_id: site.id, interval: "monthly"},
scheduled_at: first_of_month_9am(site.timezone)
)
|> Oban.insert!()
end
def first_of_month_9am(timezone) do
Timex.now(timezone)
|> Timex.shift(months: 1)
|> Timex.beginning_of_month()
|> Timex.shift(hours: 9)
end
EmailReports Module
@impl Oban.Worker
def perform(%Oban.Job{args: %{"interval" => "weekly", "site_id" => site_id}}) do
# Send weekly report email
end
@impl Oban.Worker
def perform(%Oban.Job{args: %{"interval" => "monthly", "site_id" => site_id}}) do
# Send monthly report email
end
5 Likes
5 Likes
Quantum lets you create, find and delete jobs at runtime.
Furthermore, you can pass arguments to the task function when creating a cronjob, and even modify the timezone if you’re not happy with UTC.
If your app is running as multiple isolated instances (e.g. Heroku), there are job processors backed by PostgreSQL or Redis, that also support task 2023 calendar scheduling:
1 Like
