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.

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])

@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

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”.