Share variable with all functions in a module

Questions / Help
1

Hello, everyone!
I am having a really hard time wrapping my head around this one for some reason.
I want to get a token, store it in memory in a module, have it available for all the functions in the module, and update it when the token expires.
In other languages, I might do something like:

token = nil

def handle_token() do
  # Check if I already have a token
  if token do
    # If so, use it.
    token
  else
    # If not (or if it's expired), get a new one.
    token = Req.get(www.token.com)
  end
end

This is obviously oversimplified, but I think you can understand what I mean. What is the idiomatically correct way to do this in Elixir?
I have looked into using ETS for this, but it seems like a lot.

I look forward to your feedback, and thank you!

2

Simply put, you don’t do that in an FP language (though there are escape hatches like ETS indeed).

You’ll get better responses if you specify your original problem – and not how you want to solve it.

2 Likes
3

Are you looking how you can handle state? If yes you can use Agents for storing something simple (a string)

As mentioned, you cant do what you are trying because modules are not classes, they don’t contain state.

For that you need a GenServer (which agent is just more simplified)

4

A GenServer would be perfect for that. You can even make it so that the GenServer automatically refreshes the token every interval.

e.g.

defmodule TokenManager do
  use GenServer
  
  # Stick `TokenManager` in your Application's children
  def start_link(init_arg) do
    GenServer.start_link(__MODULE__, init_arg, name: __MODULE__)
  end
  
  def token do
    GenServer.call(__MODULE__, :token)
  end
  
  def init(init_arg) do
    token = 1
    Process.send_after(self(), :refresh_token, :timer.seconds(2))
    {:ok, token}
  end
  
  def handle_call(:token, _from, token) do
    {:reply, token, token}
  end
  
  def handle_info(:refresh_token, old_token) do
    new_token = old_token + 1
    Process.send_after(self(), :refresh_token, :timer.seconds(2))
    {:noreply, new_token}
  end
end

Edit: untested code FYI

5

For a similar case, when I need to use and update something, I use the following kinda programming pattern. But as @hlx mentioned, Genserver might serve best for your case without further knowing the context of your original problem.

defmodule SomeModule do
@state %{token: nil}

def some_function(params, state) do
 state
end

def another_function(params, params2, state) do
state
end

def update_token(state) do
# update the token
%{token: updated_token}
end

end

So, I try to pass around states, between functions, so any update that happens in any function should be available to the next one. Not sure it serves your purpose, maybe you can add further context to it.

1 Like