Packages
grizzly
0.8.5
9.1.4
9.1.2
9.1.1
9.1.0
9.0.0
8.15.3
8.15.2
8.15.1
8.15.0
8.14.0
8.13.0
8.12.0
8.11.3
8.11.2
8.11.1
8.11.0
8.10.0
8.9.0
8.8.1
8.8.0
8.7.1
8.7.0
8.6.12
8.6.11
8.6.10
8.6.9
8.6.8
8.6.7
retired
8.6.6
8.6.5
8.6.4
8.6.3
8.6.2
8.6.1
8.6.0
8.5.3
8.5.2
8.5.1
8.5.0
8.4.0
8.3.0
8.2.3
8.2.2
8.2.1
8.2.0
8.1.0
8.0.1
8.0.0
7.4.3
7.4.2
7.4.1
7.4.0
7.3.0
7.2.0
7.1.4
7.1.3
7.1.2
7.1.1
7.1.0
7.0.4
7.0.3
7.0.2
7.0.1
7.0.0
6.8.8
6.8.7
6.8.6
6.8.5
6.8.4
6.8.3
6.8.2
6.8.1
6.8.0
6.7.1
6.7.0
6.6.1
6.6.0
6.5.1
6.5.0
6.4.0
6.3.0
6.2.0
6.1.1
6.1.0
6.0.1
6.0.0
5.4.1
5.4.0
5.3.0
5.2.8
5.2.7
5.2.6
5.2.5
5.2.4
5.2.3
5.2.2
5.2.1
5.2.0
5.1.2
5.1.1
5.1.0
5.0.2
5.0.1
5.0.0
4.0.1
4.0.0
3.0.0
2.1.0
2.0.0
1.0.1
1.0.0
0.22.7
0.22.6
0.22.5
0.22.4
0.22.3
0.22.2
0.22.1
0.22.0
0.21.1
0.21.0
0.20.2
0.20.1
0.20.0
0.19.1
0.19.0
0.18.3
0.18.2
0.18.1
0.18.0
0.17.7
0.17.6
0.17.5
0.17.4
0.17.3
0.17.2
0.17.1
0.17.0
0.16.2
0.16.1
0.16.0
0.15.11
0.15.10
0.15.9
0.15.8
0.15.7
0.15.6
0.15.5
0.15.4
0.15.3
0.15.2
0.15.1
0.15.0
0.14.8
0.14.7
0.14.6
0.14.5
0.14.4
0.14.3
0.14.2
0.14.1
0.14.0
0.13.0
0.12.3
0.12.2
0.12.1
0.12.0
0.11.0
0.10.3
0.10.2
0.10.1
0.10.0
0.9.0
0.9.0-rc.4
0.9.0-rc.3
0.9.0-rc.2
0.9.0-rc.1
0.9.0-rc.0
0.8.8
0.8.7
0.8.6
0.8.5
0.8.4
0.8.3
0.8.2
0.8.1
0.8.0
0.7.0
0.6.6
0.6.5
0.6.4
0.6.3
0.6.2
0.6.1
0.6.0
0.5.0
0.4.3
0.4.2
Elixir Z-Wave library
Current section
Files
Jump to
Current section
Files
lib/grizzly/command.ex
defmodule Grizzly.Command do
@moduledoc """
Command is a server managing the overall lifecycle of the execution of a command,
from start to completion or timeout.
When starting the execution of a command, the state of the network is checked to see if it is
in one of the allowed states for executing this particular command. The allowed states are listed
in the `pre_states` property of the command being started. If the property is absent, the default
allowed states are [:idle]. If the network is not in an allowed state, {:error, :network_busy} is returned.
If the started command has an `exec_state` property, the network state is set to its value for the duration
of the execution of the command. If there is none, the network state is unchanged.
If the started command has a `post_state` property, the network state is set to it after the command execution
completes or times out. If there is none, the network state is set to :idle.
If the started command has a `timeout` property, a timeout is set to its value. If the command does not complete
before the timeout expires, the command's execution is stopped and a {:timeout, <command module>} message is sent to
the process that started the execution of the command.
"""
use GenServer
alias Grizzly.{Packet, SeqNumber}
alias Grizzly.Network.State, as: NetworkState
alias Grizzly.Command.EncodeError
require Logger
@type t :: pid
@type handle_instruction ::
{:continue, state :: any}
| {:done, response :: any}
| {:retry, state :: any}
| {:send_message, message :: any, state :: any}
| {:queued, state :: any}
@callback init(args :: term) :: :ok | {:ok, command :: any}
@callback encode(command :: any) :: {:ok, binary} | {:error, EncodeError.t() | any()}
@callback handle_response(command :: any, Packet.t()) :: handle_instruction
defmodule State do
@moduledoc false
@type t :: %__MODULE__{
command_module: module(),
command: any,
timeout_ref: pid,
starter: pid
}
defstruct command_module: nil,
command: nil,
timeout_ref: nil,
starter: nil
end
@spec start(module, opts :: keyword) :: GenServer.on_start()
def start(module, opts) do
_ = Logger.debug("Starting command #{inspect(module)} with args #{inspect(opts)}")
command_args = Keyword.put_new(opts, :seq_number, SeqNumber.get_and_inc())
{:ok, command} = apply(module, :init, [command_args])
if not NetworkState.in_allowed_state?(Map.get(command, :pre_states)) do
_ =
Logger.warn(
"Command #{module} not starting in allowed network states #{
inspect(Map.get(command, :pre_states))
}"
)
{:error, :network_busy}
else
:ok = NetworkState.set(Map.get(command, :exec_state))
GenServer.start(
__MODULE__,
command_module: module,
command: command,
starter: self()
)
end
end
@spec encode(t) :: {:ok, binary} | {:error, EncodeError.t()}
def encode(command) do
GenServer.call(command, :encode)
end
@spec handle_response(t, %Packet{}) ::
{:finished, value :: any()}
| :continue
| :retry
| :queued
| {:send_message, message :: any()}
def handle_response(command, packet) do
GenServer.call(command, {:handle_response, packet}, 60_000 * 2)
end
@spec complete(t) :: :ok
def complete(command) do
GenServer.call(command, :complete)
end
@impl true
def init(
command_module: command_module,
command: command,
starter: starter
) do
timeout_ref = setup_timeout(Map.get(command, :timeout))
{
:ok,
%State{
command_module: command_module,
command: command,
timeout_ref: timeout_ref,
starter: starter
}
}
end
@impl true
def terminate(:normal, _state) do
:ok
end
def terminate(reason, %State{command: command}) do
_ =
Logger.warn(
"Command #{inspect(command)} terminated with #{inspect(reason)}. Resetting network state to idle"
)
NetworkState.set(:idle)
:ok
end
# Upon command completion, clear any timeout and
# set the network state to what the command specifies (defaults to :idle).
@impl true
def handle_call(:complete, _from, %State{command: command, timeout_ref: timeout_ref} = state) do
_ = clear_timeout(timeout_ref)
post_state = Map.get(command, :post_state, :idle)
NetworkState.set(post_state)
{:stop, :normal, :ok, %State{state | timeout_ref: nil}}
end
def handle_call(
:encode,
_,
%State{command_module: command_module, command: command} = state
) do
case apply(command_module, :encode, [command]) do
{:ok, binary} ->
{:reply, {:ok, binary}, state}
{:error, _} = error ->
{:stop, :normal, error, state}
end
end
def handle_call(
{:handle_response, %Packet{} = packet},
_from,
%State{command_module: command_module, command: command} = state
) do
case apply(command_module, :handle_response, [command, packet]) do
{:done, value} ->
{:reply, {:finished, value}, state}
{:send_message, message, new_command} ->
{:reply, {:send_message, message}, %{state | command: new_command}}
{:continue, new_command} ->
{:reply, :continue, %{state | command: new_command}}
{:retry, new_command} ->
{:reply, :retry, %{state | command: new_command}}
{:queued, new_command} ->
{:reply, :queued, %{state | command: new_command}}
end
end
@impl true
def handle_info(:timeout, %State{starter: starter, command_module: command_module} = state) do
send(starter, {:timeout, command_module})
{:stop, :normal, %State{state | timeout_ref: nil}}
end
defp setup_timeout(nil), do: nil
defp setup_timeout(timeout) do
Process.send_after(self(), :timeout, timeout)
end
defp clear_timeout(nil), do: :ok
defp clear_timeout(timeout_ref), do: Process.cancel_timer(timeout_ref)
end