How to initialize an ETS table in Phoenix?

I’m currently using Redis to cache some information in my application. But I saw that ETS may be faster at lookup actions (https://github.com/minhajuddin/redis_vs_ets_showdown) . With that in mind, I want to create an ETS table at my app startup, so I can use it in a Plug.

I’ve tried to the following, but it did not work.

defmodule MyApp.Validator do
    @bucket :ets.new(:bucket, [:set, :protected])

    def put_validation(id) do
        :ets.insert_new(@bucket, {id, %{"active" => true, "user" => "test"}}
    end
end

It returns argument error. I think it’s because the ETS does not exist.

How and where can I initialize an ETS in order to use it inside my application?

1 Like

You can do it in the start function of your application.ex, just put the init code

:ets.new(:bucket, [:set, :protected])

right before the “opts = […]”

Then in your code:

def put_validation(id) do
        :ets.insert_new(:bucket, {id, %{"active" => true, "user" => "test"}}
end

I prefer to have a dedicated GenServer, in charge of the ETS table… It starts the table in the init section.

2 Likes

It didn’t work. I’ve also removed the :protected tag, but still getting argument error.

I’ll try it! Thanks!!

Try adding the :named_table atom to the list passed into new when you initialize it:

:ets.new(:bucket, [:set, :protected, :named_table])

1 Like
@bucket :ets.new(:bucket, [:set, :protected])

This will be evaluated in compile time, after that the VM is shut down and restarted, which mean that such table will be long gone. If you need to use that table then you either need pass table ref as an argument:

defmodule MyApp.Validator do
  def create_table do
    :ets.new(:bucket, [:set, :protected])
  end

  def put_validation(table_ref, id) do
    :ets.insert_new(@bucket, {id, %{"active" => true, "user" => "test"}}
  end
end

And then use it like

table = MyApp.Validator.create_table()

MyApp.Validator.put_validation(table, :foo)

Or you need to create process that will be table owner:

defmodule MyApp.Validator do
  use GenServer

  @name __MODULE__

  def start_link(_), do: GenServer.start_link(__MODULE__, [], name: @name)

  def insert(id) do
    GenServer.call(@name, {:insert, id})
  end

  def init(_) do
    :ets.new(@name, [:set, :protected, :named_table])

    {:ok, []}
  end

  def handle_call({:insert, id}, _ref, state) do
    :ets.insert_new(@name, {id, %{"active" => true, "user" => "test"}})

    {:reply, :ok, state}
  end
end
5 Likes

I’ve created a GenServer as you and @kokolegorille suggested and it worked! Thank you very much.

Just to register what I’ve done, so others can see it.

I created a file called validator.ex inside my lib/myapp/ folder with:

defmodule MyApp.Validator do
    use GenServer

    @name __MODULE__

    def start_link(_), do: GenServer.start_link(__MODULE__, [], name: @name)

    def init(_) do
      IO.puts("Creating ETS #{@name}")
      :ets.new(:authorization_bucket, [:set, :named_table])
      {:ok, "ETS Created"}
    end

    def insert(token, model_id) do
      GenServer.call(@name, {:insert, {token, %{"active" => true, "model_id" => model_id}}})
    end

    def remove(token) do
      GenServer.call(@name, {:delete, token})
    end

    def handle_call({:insert, data}, _ref, state) do
      :ets.insert_new(:authorization_bucket, data)
      {:reply, :ok, state}
    end

    def handle_call({:delete, token}, _ref, state) do
      :ets.delete(:authorization_bucket, token)
      {:reply, :ok, state}
    end

    def create_ets_bucket() do
      :ets.new(:authorization_bucket, [:set, :protected, :named_table])
    end
end

Then, I start the GenServer at lib/myapp/application.ex

def start(_type, _args) do
    # List all child processes to be supervised
    children = [
      # Start the Ecto repository
      MyApp.Repo,
      # Start the endpoint when the application starts
      MyAppWeb.Endpoint,
      # Starts a worker by calling: MyApp.Worker.start_link(arg)
      # {MyApp.Worker, arg},
      MyApp.Validator
    ]
    # See https://hexdocs.pm/elixir/Supervisor.html
    # for other strategies and supported options
    opts = [strategy: :one_for_one, name: MyApp.Supervisor]
    Supervisor.start_link(children, opts)
  end

To test it, start the server with iex -S mix phx.server. When MyApp.Validator.init/1 is called, it prints “Creating ETS MyApp.Validator”.

3 Likes