Task.await/1 calls exit/1 on timeout, so it will end your current process. If you do not wan’t that behaviour you will have to implement the receiving of the result and receiving of :DOWN messages on your own.

I’m still getting to grips with Tasks myself, but I think it’s because the Task is linked to the calling process, so if it throws an error and exits, then the calling process will also die. See Task — Elixir v1.20.2

You could use Task.start_link/1 if you don’t need the response, I’ve been using a Task.Supervisor for mine, so that if a Task dies, it doesn’t bring the genserver down.

Add a supervisor:

supervisor(Task.Supervisor, [[name: App.MyTaskSupervisor]])

Then can use it like:

def do_work(some_data) do
  Enum.map(some_data, fn(x) ->
    Task.Supervisor.async_nolink(App.MyTaskSupervisor, fn ->
      case HTTPoison.post(.....) do

Because I wnted to know if it was a timeout, I use yield

task = Task.Supervisor.async_nolink(
  App.MyTaskSupervisor,
  MyModule,
  :task_function,
  [args]
)

case Task.yield(task) || Task.shutdown(task) do
  {:ok, result} ->
    ack_message({:ok, %{channel: channel, tag: tag}})
  
  {:error, msg} ->
    ack_message({:error, %{error: msg, channel: channel, tag: tag, redelivered: redelivered}})

  {:exit, reason} ->
    ack_message({:error, %{error: reason, channel: channel, tag: tag, redelivered: redelivered}})

  nil ->
    ack_message({:error, %{error: "TIMEOUT", channel: channel, tag: tag, redelivered: redelivered}})
end

How and where?

Or maybe I could

1. use try…catch inside Task.await
2. or use Task.yield?

but I already have this in:

  def start(_type, _args) do
    import Supervisor.Spec

    children = [supervisor(MyWebApp.Repo, []), supervisor(MyWebApp.Endpoint, []),
                worker(MyWebApp.MyGenServer, [])]

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

I’m not sure what you mean by using try/catch in Task.await/1, since you can’t alter Task.await/1. You can look at its implementation though to see how the different kind of messages look like, then you will know how to math them in handle_info/2. I’m not quite sure what will be the best way to time out a Task then, though…

If you mean you wan’t to wrap Task.await/1 with try/catch, this won’t work either. exit/1 does end the process. It does end the process. There is no try, nothing raised or thrown, only exit.

Again, I’m not sure this is the best way as I’m still learning myself, but something like:

Add supervisor(Task.Supervisor, [[name: MyWebApp.TaskSupervisor]]) to the app

def start(_type, _args) do
  import Supervisor.Spec

  children = [
    supervisor(MyWebApp.Repo, []),
    supervisor(MyWebApp.Endpoint, []),
    worker(MyWebApp.MyGenServer, []),
    supervisor(Task.Supervisor, [[name: MyWebApp.TaskSupervisor]]) # This is added
  ]

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

Then inside MyWebApp.MyGenServer you could do:

def do_work(some_data) do
  Enum.map(some_data, fn(x) ->
    Task.Supervisor.async(MyWebApp.TaskSupervisor, fn -> # Use the Task.Supervisor here
      case HTTPoison.post(.....) do

The reason I switched to using Task.yield was because I wanted to be able to trap timeouts (it sends back nil) so that I could do something with it.

I mean this:

Task.async fn ->
  try do
    # http request
  catch
  end
end

How about Task.yield instead Task.async, will it work?

How will I know that it’s the “exit” or :DOWN sent exactly from that Task.await?

That of course would work, but you have to do it in every Task you spawn, also this will not do anything about a timeout in Task.await/1!

What do you wan’t to return in the case that there was no answer before having the yield timing out?

It won’t exit on raise though, but give you an :error-tuple which you could return straight.

By using a map to map your Task to your callers. roughly like this:

def handle_call(:foo, from, state) do
  task = Task.async(&do_stuff/0)
  state = Map.put(state, task.ref, from)
  {:noreturn, state}
end

How to pull of the correct value from the state is left as an exercise for the reader Also I have to admit that the code is untested since I currently have no access to a properly set up elixir environment.