Sending messages from an external script to a running Elixir app

I think you can do this in multiple ways. Define a port to receive messages or use the rpc to send messages directly in elixir.

/path/to/_build/prod/rel/my_app/bin/my_app rpc "Genserver.cast(...)"

Yep, I use something like this to update my blog when I have added a new post or modified an existing one:

sudo -u www-data /var/www/blog/bin/mebe rpc "GenServer.call(Mebe2.Engine.Worker, :refresh, 30_000)"

Mix releases include the “rpc” script builtin.

Really cool solution!

ps: Security Notes:

• I hope your document root is not pointed at /var/www
• You have directory listing and all the other nice stuff disabled with the default apache or another unix handler
• For the future please create a specific user for your projects, applications, scripts and put them into respective directories and run from that location with that user

ie: blog

user: blog
homedir: /home/blog

$ > ps
... blog ...... /home/blog/bin/mebe ...... 

The rpc solutions looks easy, but that’s only for release? I’d like to run this in dev (maybe even test?) as well.

Hi and thanks for the concern. My document root is indeed not /var/www, and directory listing is not enabled. The blog could sure run with a different user, but there is nothing interesting on the server that the user could access, so I’m not too worried about it. But should leave a note to do it the next time I do something on the box.

But this is not at all related to the matter at hand.

To do this in development, you can start your application with a name (--name or --sname) and then use IEx’s --rpc-eval flag (and I think IEx also needs to be given a different name).

rpc is good; however fairly slow because it need to start up a separate erlang node just to talk to the existing running system. If you need to interact with the running system every second, you can make a simple server listening on a UNIX domain socket, that respond to a minimal text based API. This is fairly simple with gen_tcp. Another benefit (at least in my view) is you get to limit what you respond to. My client program is just a shell script that invokes socat.

beam_notify might be a good library to look into: GitHub - nerves-networking/beam_notify: Send a message from a shell script to the BEAM · GitHub

Excellent, looks like just what I wanted.

For reference, this is what I got working:

defmodule Notify do
  use GenServer

  def start_link(args) do
    GenServer.start_link(__MODULE__, args, name: __MODULE__)
  end

  @impl true
  def init(_opts) do
    BEAMNotify.start_link(
      path: "/tmp/notify_socket",
      dispatcher: &send(__MODULE__, {:notify, &1, &2})
    )
  end

  @impl true
  def handle_info({:notify, msg, _}, state) do
    IO.inspect(msg)
    {:noreply, state}
  end
end

And the script in priv:

#!/bin/sh

BEAM_NOTIFY=$(ls $(dirname $0)/../_build/dev/lib/beam_notify/priv/beam_notify)
$BEAM_NOTIFY -p /tmp/notify_socket -- $1

I’ll have to modify the beam_notify path in production, but other than that I’m good to go.