Write your own CRON with Elixir

defmodule Omycron.Application do
  @moduledoc """
  Main supervisor for Omycron
  """
  use Application

  @impl true
  def start(_type, _args) do
    children = []

    opts = [strategy: :one_for_one, name: Omycron.Supervisor]
    Supervisor.start_link(children, opts)
  end
end

[[task]]
name = "Im alive"
interval = {second = 3}
command = "echo"
params = ["i'am alive"]

[[task]]
name = "list folder"
interval = {second = 10, minute = 1}
command = "ls"
params = ['-a', '-l']

[[task]]
name = "a new day"
interval = {hour = 24}
command = "date"

import Config

config :omycron,
  tasks_pathname: "./omycron.toml"

defmodule Omycron.Tasks.Agent do
  @moduledoc """
  Store the tasks
  """
  use Agent

  def start_link([config_pathname]) do
    IO.puts("IM STARTING !")
    Agent.start_link(fn -> %{} end, name: __MODULE__)
  end
end

# ...

def start(_type, _args) do
  children = [
    Omycron.Tasks.Agent.child_spec()
  ]
# ...
end

  defp deps do
    [
      {:toml_elixir, "~> 2.0.0"}
    ]
  end

defmodule Omycron.Tasks.Parser do
   @moduledoc """
  Parse the TOML config file
  """

  defmodule __MODULE__.Task do
    @moduledoc """
    Define a struct that contains all the properties for a Task
    """
    defstruct name: nil, command: nil, params: [], interval: nil
  end

  @doc """
  Start the parsing
  """
  @spec parse(String.t()) :: {:ok, list(any)} | {:error, String.t()}
  def parse(pathname) do
    # Use toml_elixir to read the file
    TomlElixir.parse_file(pathname)
    # parse_content use the value returned by toml_elixir
    |> parse_content()
    # `tap` execute a function and returns the value passed as parameters
    # this is used temporary to print the result and still return the tasks
    |> tap(&IO.puts("Parsed tasks > #{inspect(&1)}"))
  end

  ## In case `toml_elixir` returns an error, we display a proper error message
  ## and exit the program
  defp parse_content({:error, error_type}) do
    case error_type do
      :enoent -> write_error("Config file is missing")
      _ -> write_error("Failed to parse config file")
    end

    write_error("Program exits.")
    exit(:shutdown)
  end

  ## If `toml_elixir` was successful, we parse the content
  ## we use pattern matching to direcly access the array of tasks
  defp parse_content({:ok, %{"task" => tasks}}) do
    parse_tasks(tasks, [])
  end

  ## parse_tasks loop trough all tasks (thanks to pattern matching)
  ## 	and process them one by one.
  ## Once its done, it returns `parsed_tasks`
  defp parse_tasks([], parsed_tasks), do: parsed_tasks

  defp parse_tasks([task | tail], parsed_tasks),
    do: parse_tasks(tail, [parse_task(task) | parsed_tasks])

  ## parse_task takes the raw data returned from `toml_elixir`
  ## and cast it into a Task struct defined earlier
  ## we use pattern matching to make sure the format is correct
  defp parse_task(%{"name" => name, "command" => command, "params" => params, "interval" => interval}),
    do: %__MODULE__.Task{
      name: name,
      command: command,
      params: params,
      interval: interval_to_ms(interval)
    }

  ## In case the file has a invalid entry, we print an error message
  ##   and exit the program
  defp parse_task(invalid_task) do
    write_error("Invalid command > #{inspect(invalid_task)}")
    exit(:shutdown)
  end
  
  ## we gradually merge hour to minute then minute to second and finally second to ms
  defp interval_to_ms(%{"second" => second, "minute" => minute, "hour" => hour}),
    do: interval_to_ms(%{"second" => second, "minute" => minute + hour * 60})

  defp interval_to_ms(%{"second" => second, "minute" => minute}),
    do: interval_to_ms(%{"second" => second + minute * 60})

  defp interval_to_ms(%{"second" => second}),
    do: second * 1000

  # write on stderr
  defp write_error(str), do: IO.write(:standard_error, str)
end

 def start_link([config_pathname]) do
    Agent.start_link(fn -> Omycron.Tasks.Parser.parse(config_pathname) end, name: __MODULE__)
 end

children = [
  Omycron.Tasks.Agent.child_spec([Application.fetch_env!(:omycron, :tasks_pathname)])
]

defmodule Omycron.Tasks do
  @moduledoc """
  Helpers for tasks
  """

  @doc """
  Retrive the list of tasks
  """
  def get do
    Agent.get(__MODULE__.Agent, & &1)
  end
end

defmodule Omycron.Runner do
  @moduledoc """
  We use a GenServer (a sub-process) that will use the erlang `timer` module to send itself an event that will start the execution of a task
  """
  use GenServer

  @doc """
  Follow the official documentation of GenServer
  """
  def start_link(opts), do: GenServer.start_link(__MODULE__, opts, name: __MODULE__)

  @impl true
  def init(_opts) do
    # small trick to wait for the tasks to load everything
    :timer.send_after(1000, :start)
    {:ok, nil}
  end

  @doc """
  Load the list of tasks and start each of them one by one
  """
  @impl true
  def handle_info(:start, _params) do
    with tasks <- OMC.Tasks.get(),
         :ok <- Enum.each(tasks, &setup_task(&1)) do
      {:noreply, tasks}
    else
      _err -> :error
    end
  end

  @doc """
  Execute a Task and print the result
  """
  @impl true
  def handle_info(
        {:execute, %OMC.Tasks.Parser.Task{name: name, command: command, params: params}},
        tasks
      ) do
    {res, _} = System.cmd(command, params)
    IO.puts("Task #{name} executed successfully:\n#{inspect(res)}\n")
    {:noreply, tasks}
  end

  ## use the `send_interval` function to trigger an event to itself everytime the task should run
  defp setup_task(%OMC.Tasks.Parser.Task{interval_in_ms: interval_in_ms} = task) do
    :timer.send_interval(interval_in_ms, {:execute, task})
  end
end