GenServer pass file path

My guidelines for config is as follows:

1. If it’s functions, receive config via params
2. If it’s processes, receive config via params given to the childspec
3. If the above is not convenient for the default use case, additionally fall back to application env or other stateful configuration methods.

For your case I’m wondering why you need a process (genserver) at all. If all you do is either startup or not you don’t really need to check the genserver at runtime anymore. If things failed the app doesn’t start to begin with.

I’d go for:

with {:ok, result} <- Lib.populate(path) do
  case result do
    :indexation_successful -> Logger.info("Application launched successfully.")
    {:partial_indexation_successful, fails} -> Logger.info("Application launched with errors. Check the CSV file for: #{inspect fails}")
  end
  Logger.info("Waiting for requests.")
  Supervisor.start_link(children, opts)
end

You could add more logging to the failing part, but the not starting application does already cause logs to be generated. If you’d skip the logging for the success case it’s even more simple than that.

An alternative I can see, which doesn’t require wrapping Supervisor.start_link could be:

children = [
  {Lib.Populator, [path]},
  …
]
Supervisor.start_link(children, opts)

Where the Populator succeeds or fails to start depending on the result of loading the file. After a success the process could just hibernate. Here the population would be done at init/1 and block till finished and everything starting later can just use the data as needed.

If you don’t want to block on startup you can use the above as well, do the loading after init/1, but you essentially need to query the state of loading the file whenever you try to access it and also it’s not as straight forward in terms of stopping the application, as there might already be more things started.

For your case I’m wondering why you need a process (genserver) at all. If all you do is either startup or not you don’t really need to check the genserver at runtime anymore. If things failed the app doesn’t start to begin with.

This decision stems from this discussion:

Where I was advised to create a GenServer that monitors the file, and self-heals the applications once the file is corrected. With the file corrected, the GenServer then does nothing and in theory I could kill it, but for the time being I am leaving it be (for simplicity reasons).

An alternative I can see, which doesn’t require wrapping Supervisor.start_link could be:

I am already using this alternative, but then path needs to be hardcoded, which is against the guidelines for libraries. I honestly do not see a situation where I can abide for the best practices guidelines and the advice given by the community.

This is already being done and is expected. It’s a cheap operation and not a problem.

This kinda contradicts your snippet in the entry post, which does fail hard if the file could not be loaded, while self healing means you just start up not matter what and wait for it to heal. Maybe there’s some timeout, but you initially accept it to not work.

Maybe you could first define what should happen in case of errors. Should the application fail to start up, stop after a timeout, not fail at all and just deal with data not being available or should even the user of your application make the decision?

If that’s part of you library users’ supervision tree your library itself does not hardcode anything. And yeah, all my code examples would live in the users MyApp.Application, not your library. I missed specifying that.

Let me see if I get this correctly. The app that uses my library, would then have the following code:

defmodule FootbalInterface.Application do
  @moduledoc false

  use Application

  alias FootbalEngine

  require Logger

  def start(_type, _args) do

    children = [
        {FootbalEngine, "path_to_file"}
    ]
    opts = [strategy: :one_for_one, name: FootbalInterface.Supervisor]
  end
end

Correct?

This is actually what I have been trying to achieve, except I don’t quite know how to prepare my library to be used like that.

Questions

1. Is there any documentation or tutorial you could point me to ?
2. Would my FootbalEngine app still be an OTP application, or would it be a simple library?
3. Would it still have an applixation.ex file with use Application?
4. Would it simply returns the Supervisor in the Footbal.new function?

Would really appreciate some guidelines.

It would be a library without own supervision tree. It just has module(s), which can be started by other applications. There’s therefore no need for an application.ex in your library.

I’m not sure what supervisor you’d need in your library if FootbalEngine is a genserver.