Package published to finitomata | Hex
(25ec5990045d025fba2bb1c59a92e08fc8a045fdd347fcdcb885f22c75a1f2d2)

Introduces Infinitomata module as a drop-in replacement of Finitomata.{start_fsm/4,transition/4,state/3}. It transparently runs in a cluster, leveraging process groups :pg to keep track of spawned instances.

Example from tests:

defmodule InfinitomataTest do
  use ExUnit.Case, async: true
  @moduletag :distributed

  setup do
    {_peers, _nodes} = Enfiladex.start_peers(3) # start 3 peers
    Enfiladex.block_call_everywhere(Infinitomata, :start_link, [])
  end

  test "many instances (distributed)" do
    for i <- 1..10 do
      Infinitomata.start_fsm("FSM_#{i}", Finitomata.Test.Log, %{instance: i})
    end

    assert Infinitomata.count(Infinitomata) == 10

    for i <- 1..10 do
      Infinitomata.transition("FSM_#{i}", :accept)
    end

    assert %{"FSM_1" => %{}} = Infinitomata.all(Infinitomata)

    for i <- 1..10 do
      Infinitomata.transition("FSM_#{i}", :__end__)
    end

    Process.sleep(1_000)

    assert Infinitomata.count(Infinitomata) == 0 # all finished ending state
    assert Infinitomata.all(Infinitomata) == %{}
  end
end

Why is that?

could you demo a door

Sure. The code below is untested, but the idea is correct.

defmodule Door do
  @fsm """
    unplugged --> |on!| closed
    closed --> |button| input
    closed --> |off| dismantled
    input --> |button| input,unlocked,locked
    unlocked --> |plumber| closed
    locked --> |plumber| closed
  """

  use Finitomata, fsm: @fsm, timer: 10, impl_for: :all, auto_terminate: true

  @impl true
  # entering `input`
  def on_transition(:closed, :button, button, %{code: code, entered: []} = state),
    do: {:ok, :input, Map.update(state, :entered, & [button | &1])}

  # processing input
  def on_transition(:input, :button, button, %{code: code, entered: current} = state) do
    current = [button | current]
    cond do
      valid?(current, code) -> {:ok, :unlocked, Map.put(state, entered: [])}
      length(current) >= 10 -> {:ok, :locked, Map.put(state, entered: [])}
      true -> {:ok, :input, Map.put(state, entered: current)}
    end
  end
 
  def on_timer(:locked, %{locked_from: timestamp} = state) do
    if elapsed_lock?(timestamp),
      do: {:transition, :plumber, state}, # unlock
      else: {:ok, state}
  end

  def on_timer(:input, state) do
    if elapsed_timeout?(timestamp),
      do: {:transition, :plumber, Map.put(state, :entered, [])}, # reset
      else: {:ok, state}
  end
end

I didn’t implement private helpers like elapsed?/1 and valid?/2 because they are trivial.

Thanks @mudasobwa your breakdown definitely improved my thinking. I can see how a generator might be a pain to deal with in source control etc. And the distinction between run-time, compile-time and deploy-time is helpful as well. Thanks again for the library, I’ll give it a run