defmodule MishkaInstaller.PluginState do
@moduledoc """
This module served as the first layer in the domain of plugin state management in earlier versions;
however, following optimization using ETS, it is now regarded as the main structure in the second layer.
If a developer chooses to construct a custom plugin by using the `use MishkaInstaller.Hook` directive,
then the developer actually implements this module as the first layer to register a plugin and the second layer as a supervisor.
The scope of a plugin's state management is not restricted to the automatically specified duties performed by the `MishkaInstaller`;
for instance, it provides developers with a temporary state and offers them the freedom to act in accordance with whatever method they choose.
### Each plugin should have these parameters
```elixir
defstruct [:name, :event, priority: 1, status: :started, depend_type: :soft, depends: [], extra: [], parent_pid: nil]
```
### Module communication process of MishkaInstaller.PluginState
```
+------------------------------------------------+
| |
| |
+------+ MishkaInstaller.PluginStateDynamicSupervisor |
| | |
| | |
| +--------------------------------------+----^----+
| | |
| | |
| | |
| +------------------------+ | |
| | | | |
+------> PluginStateRegistry | | |
| | | |
+--------^---------------+ | |
| | |
| | |
| | |
| | |
| +--------------------v----+-----+
| | |
| | MishkaInstaller.PluginState |
+--------+ |
+--------------------+--------^-+
| |
| |
| |
| |
+----------------------------+ | |
| | | |
| MishkaInstaller.PluginETS <------+ |
| | |
+----------------------------+ |
|
|
|
+--------------------+-+
| |
+-------------+ MishkaInstaller.Hook |
| | |
| +----------------------+
|
|
+---------v----------------------+
| |
| Behaviour References |
| |
+--------------------------------+
```
"""
use GenServer
require Logger
alias MishkaInstaller.PluginStateDynamicSupervisor, as: PSupervisor
alias MishkaInstaller.Plugin
alias __MODULE__
defstruct [
:name,
:event,
:extension,
priority: 1,
status: :started,
depend_type: :soft,
depends: [],
extra: [],
parent_pid: nil
]
@typedoc "This type can be used when you want to introduce the parameters of a plugin"
@type params() :: map()
@typedoc "This type can be used when you want to introduce an ID of a plugin"
@type id() :: String.t()
@typedoc "This type can be used when you want to introduce an plugin name"
@type module_name() :: String.t()
@typedoc "This type can be used when you want to introduce an event name"
@type event_name() :: String.t()
@typedoc "This type can be used when you want to introduce an event owner extension"
@type extension() :: String.t()
@typedoc "This type can be used when you want to introduce an event"
@type plugin() :: %PluginState{
name: module_name(),
event: event_name(),
extension: module(),
priority: integer(),
status: :started | :stopped | :restarted,
depend_type: :soft | :hard,
parent_pid: any(),
depends: list(String.t()),
extra: list(map())
}
@typedoc "This type can be used when you want to introduce an event"
@type t :: plugin()
@doc """
You should in no way use this function in its direct form. The supervisor coverage needs to run before using this function since
it will establish a state for your plugin and save its PID in the registry.
Make use of the function named `MishkaInstaller.PluginStateDynamicSupervisor.start_job/1`.
"""
def start_link(args) do
{id, type, parent_pid} =
{Map.get(args, :id), Map.get(args, :type), Map.get(args, :parent_pid)}
GenServer.start_link(__MODULE__, default(id, type, parent_pid), name: via(id, type))
end
@doc false
def child_spec(process_name) do
%{
id: __MODULE__,
start: {__MODULE__, :start_link, [process_name]},
restart: :transient,
max_restarts: 4
}
end
defp default(plugin_name, event, parent_pid) do
%PluginState{name: plugin_name, event: event, parent_pid: parent_pid}
end
@doc """
This function helps you to create the state of a plugin. Please see `t:plugin/0` type documents. This function does not wait for a response.
## Examples
```elixir
plugin =
%MishkaInstaller.PluginState{
name: "unnested_plugin_five",
event: "nested_event_one",
depend_type: :hard,
depends: ["unnested_plugin_four"]
}
MishkaInstaller.PluginState.push(plugin)
```
"""
@spec push(MishkaInstaller.PluginState.t()) :: :ok | {:error, :push, any}
def push(%PluginState{} = element) do
case PSupervisor.start_job(%{
id: element.name,
type: element.event,
parent_pid: element.parent_pid
}) do
{:ok, status, pid} -> GenServer.cast(pid, {:push, status, element})
{:error, result} -> {:error, :push, result}
end
end
@doc """
This function does the same thing as the `push/1` function, except that it waits for a response.
"""
@spec push_call(MishkaInstaller.PluginState.t()) :: :ok | {:error, :push, any}
def push_call(%PluginState{} = element) do
case PSupervisor.start_job(%{
id: element.name,
type: element.event,
parent_pid: element.parent_pid
}) do
{:ok, status, pid} ->
if Mix.env() == :test, do: Logger.warn("Plugin State of #{element.name} is being pushed")
GenServer.call(pid, {:push, status, element})
{:error, result} ->
{:error, :push, result}
end
end
@doc """
It gets a plugin information from the state.
## Examples
```elixir
MishkaInstaller.PluginState.get(module: "PluginTest")
```
"""
@spec get([{:module, module_name()}]) :: plugin() | {:error, :get, :not_found}
def get(module: module_name) do
case PSupervisor.get_plugin_pid(module_name) do
{:ok, :get_plugin_pid, pid} -> GenServer.call(pid, {:pop, :module})
{:error, :get_plugin_pid} -> {:error, :get, :not_found}
end
end
@doc """
This function gets all information of plugins which are under a specific event.
## Examples
```elixir
MishkaInstaller.PluginState.get_all(event: "event_test")
```
"""
def get_all(event: event_name) do
PSupervisor.running_imports(event_name) |> Enum.map(&get(module: &1.id))
end
@doc """
This function gets all information of plugins which are pushed on the state.
## Examples
```elixir
MishkaInstaller.PluginState.get_all()
```
"""
def get_all() do
PSupervisor.running_imports() |> Enum.map(&get(module: &1.id))
end
@doc """
Delete a plugin or plugins based on a specific event from the state.
## Examples
```elixir
MishkaInstaller.PluginState.delete(module: "PluginTest")
# or
MishkaInstaller.PluginState.delete(event: "EventTest")
```
"""
def delete(module: module_name) do
case PSupervisor.get_plugin_pid(module_name) do
{:ok, :get_plugin_pid, pid} ->
GenServer.cast(pid, {:delete, :module})
{:ok, :delete}
{:error, :get_plugin_pid} ->
{:error, :delete, :not_found}
end
end
def delete(event: event_name) do
PSupervisor.running_imports(event_name) |> Enum.map(&delete(module: &1.id))
end
@doc """
Terminate a PID from the supervisor directly.
## Examples
```elixir
MishkaInstaller.PluginState.delete_child(module: "PluginTest")
```
"""
def delete_child(module: module_name) do
case PSupervisor.get_plugin_pid(module_name) do
{:ok, :get_plugin_pid, pid} -> DynamicSupervisor.terminate_child(PluginStateOtpRunner, pid)
{:error, :get_plugin_pid} -> {:error, :delete, :not_found}
end
end
@doc """
Terminate all PIDs of the plugin state from the supervisor directly.
## Examples
```elixir
MishkaInstaller.PluginState.terminate_all_pids()
```
"""
def terminate_all_pids() do
Enum.map(PSupervisor.running_imports(), fn item ->
GenServer.cast(item.pid, {:delete, :module})
end)
end
@doc """
Stop a plugin state.
## Examples
```elixir
MishkaInstaller.PluginState.stop(module: PluginTest)
# or
MishkaInstaller.PluginState.stop(event: "event_test")
```
"""
def stop(module: module_name) do
case PSupervisor.get_plugin_pid(module_name) do
{:ok, :get_plugin_pid, pid} ->
GenServer.cast(pid, {:stop, :module})
{:ok, :stop}
{:error, :get_plugin_pid} ->
{:error, :stop, :not_found}
end
end
def stop(event: event_name) do
PSupervisor.running_imports(event_name) |> Enum.map(&stop(module: &1.id))
end
# Callbacks
@impl true
def init(%PluginState{} = state) do
if Mix.env() == :test, do: MishkaInstaller.Database.Helper.get_parent_pid(state)
Logger.info(
"#{Map.get(state, :name)} from #{Map.get(state, :event)} event of Plugins manager system was started"
)
{:ok, state, {:continue, {:sync_with_database, :take}}}
end
@impl true
def handle_call({:pop, :module}, _from, %PluginState{} = state) do
{:reply, state, state}
end
@impl true
def handle_call({:push, _status, %PluginState{} = element}, _from, %PluginState{} = _state) do
element
|> Map.from_struct()
|> Plugin.add_or_edit_by_name()
{:reply, element, element}
end
@impl true
def handle_cast({:push, status, %PluginState{} = element}, _state) do
{:noreply, element, {:continue, {:sync_with_database, status}}}
end
@impl true
def handle_cast({:stop, :module}, %PluginState{} = state) do
new_state = Map.merge(state, %{status: :stopped})
{:noreply, new_state, {:continue, {:sync_with_database, :edit}}}
end
@impl true
def handle_cast({:delete, :module}, %PluginState{} = state) do
MishkaInstaller.plugin_activity("destroy", state, "high", "report")
{:stop, :normal, state}
end
@impl true
def handle_continue({:sync_with_database, _status}, %PluginState{} = state) do
state
|> Map.from_struct()
|> Plugin.add_or_edit_by_name()
|> check_output(state)
{:noreply, state}
end
@impl true
def handle_continue({:sync_with_database, :take}, %PluginState{} = state) do
state =
case Plugin.show_by_name("#{state.name}") do
{:ok, :get_record_by_field, _error_atom, record_info} ->
struct(__MODULE__, Map.from_struct(record_info))
{:error, _result, _error_atom} ->
state
end
{:noreply, state}
end
if Mix.env() in [:test, :dev] do
@impl true
def handle_info({:DOWN, _ref, :process, _pid, _reason}, state) do
# log that this happened, etc. Don't use Repo!
{:stop, :normal, state}
end
end
@impl true
def terminate(reason, %PluginState{} = state) do
MishkaInstaller.plugin_activity("read", state, "high", "throw")
if reason != :normal do
Task.Supervisor.start_child(PluginEtsTask, fn ->
MishkaInstaller.PluginETS.sync_with_database()
end)
Logger.warn(
"#{Map.get(state, :name)} from #{Map.get(state, :event)} event of Plugins manager was Terminated,
Reason of Terminate #{inspect(reason)}"
)
end
end
defp via(id, value) do
{:via, Registry, {PluginStateRegistry, id, value}}
end
defp check_output({:error, status, _, _} = _output, %PluginState{} = state) do
MishkaInstaller.plugin_activity("#{status}", state, "high", "error")
end
defp check_output({:ok, status, _, _} = _output, %PluginState{} = state) do
action =
cond do
status == :add -> "add"
state.status == :stopped -> "delete"
true -> "edit"
end
MishkaInstaller.plugin_activity(action, state, "high")
end
end
