defmodule OpcUA.Server do
use OpcUA.Common
alias OpcUA.{NodeId}
@moduledoc """
OPC UA Server API module.
This module provides functions for configuration, add/delete/read/write nodes and discovery a OPC UA Server.
`OpcUA.Server` is implemented as a `__using__` macro so that you can put it in any module,
you can initialize your Server manually (see `test/server_tests/write_event_test.exs`) or by overwriting
`configuration/1` and `address_space/1` to autoset the configuration and information model. It also helps you to
handle Server's "write value" events by overwriting `handle_write/2` callback.
The following example shows a module that takes its configuration from the environment (see `test/server_tests/terraform_test.exs`):
```elixir
defmodule MyServer do
use OpcUA.Server
alias OpcUA.Server
# Use the `init` function to configure your server.
def init({parent_pid, 103} = _user_init_state, opc_ua_server_pid) do
Server.start(opc_ua_server_pid)
%{parent_pid: parent_pid}
end
def configuration(_user_init_state), do: Application.get_env(:opex62541, :configuration, [])
def address_space(_user_init_state), do: Application.get_env(:opex62541, :address_space, [])
def handle_write(write_event, %{parent_pid: parent_pid} = state) do
send(parent_pid, write_event)
state
end
end
```
Because it is small a GenServer, it accepts the same [options](https://hexdocs.pm/elixir/GenServer.html#module-how-to-supervise) for supervision
to configure the child spec and passes them along to `GenServer`:
```elixir
defmodule MyModule do
use OpcUA.Server, restart: :transient, shutdown: 10_000
end
```
"""
@doc """
Optional callback that handles node values updates from a Client to a Server.
It's first argument will a tuple, in which its first element is the `node_id` of the updated node
and the second element is the updated value.
the second argument it's the GenServer state (Parent process).
"""
@callback handle_write(key :: {%NodeId{}, any}, term()) :: term()
@type config_params ::
{:hostname, binary()}
| {:port, non_neg_integer()}
| {:users, keyword()}
@type config_options ::
{:config, config_params}
| {:discovery, {binary(), non_neg_integer()}}
@doc """
Optional callback that gets the Server configuration and discovery connection parameters.
"""
@callback configuration(term()) :: config_options
@type address_space_list ::
{:namespace, binary()}
| {:variable_node, %OpcUA.VariableNode{}}
| {:variable_type_node, %OpcUA.VariableTypeNode{}}
| {:method_node, %OpcUA.MethodNode{}} #WIP
| {:object_node, %OpcUA.ObjectNode{}}
| {:object_type_node, %OpcUA.ObjectTypeNode{}}
| {:reference_type_node, %OpcUA.ReferenceTypeNode{}}
| {:data_type_node, %OpcUA.DataTypeNode{}}
| {:view_node, %OpcUA.ViewNode{}}
| {:reference_node, %OpcUA.ReferenceNode{}}
| {:monitored_item, %OpcUA.MonitoredItem{}}
@doc """
Optional callback that gets a list of nodes (with their attributes) to be automatically set.
"""
@callback address_space(term()) :: address_space_list
defmacro __using__(opts) do
quote location: :keep, bind_quoted: [opts: opts] do
use GenServer, Keyword.drop(opts, [:configuration])
@behaviour OpcUA.Server
@mix_env Mix.env()
alias __MODULE__
def start_link(user_initial_params \\ []) do
GenServer.start_link(__MODULE__, user_initial_params, unquote(opts))
end
@impl true
def init(user_initial_params) do
send self(), :init
{:ok, user_initial_params}
end
@impl true
def handle_info(:init, user_initial_params) do
# Server Terraform
{:ok, s_pid} = OpcUA.Server.start_link()
configuration = apply(__MODULE__, :configuration, [user_initial_params])
address_space = apply(__MODULE__, :address_space, [user_initial_params])
OpcUA.Server.set_default_config(s_pid)
# configutation = [config: list(), discovery: {term(), term()}]
set_server_config(s_pid, configuration, :config)
set_server_config(s_pid, configuration, :discovery)
# address_space = [namespace: "", namespace: "", variable: %VariableNode{}, ...]
set_server_address_space(s_pid, address_space)
# User initialization.
user_state = apply(__MODULE__, :init, [user_initial_params, s_pid])
{:noreply, user_state}
end
def handle_info({%NodeId{} = node_id, value}, state) do
state = apply(__MODULE__, :handle_write, [{node_id, value}, state])
{:noreply, state}
end
@impl true
def handle_write(write_event, state) do
require Logger
Logger.warn("No handle_write/2 clause in #{__MODULE__} provided for #{inspect(write_event)}")
state
end
@impl true
def address_space(_user_init_state), do: []
@impl true
def configuration(_user_init_state), do: []
defp set_server_config(s_pid, configuration, type) do
config_params = Keyword.get(configuration, type, [])
Enum.each(config_params, fn(config_param) -> GenServer.call(s_pid, {type, config_param}) end)
end
defp set_server_address_space(s_pid, address_space) do
for {node_type, node_params} <- address_space, reduce: %{} do
acc -> add_node(s_pid, node_type, node_params, acc)
end
end
defp add_node(s_pid, :namespace, node_param, namespaces) do
ns_index = GenServer.call(s_pid, {:add, {:namespace, node_param}})
Map.put(namespaces, node_param, ns_index)
end
defp add_node(s_pid, node_type, node, namespaces) do
# separate the node params (creation arguments & node attributes)
{node_args, node_attrs} =
node
|> Map.from_struct()
|> Map.pop(:args)
# Create node
#node_args = replace_namespace(node_args, namespaces)
GenServer.call(s_pid, {:add, {node_type, node_args}})
# add nodes attribures
node_id = Keyword.get(node_args, :requested_new_node_id, nil)
#node_attrs = replace_namespace(node_attrs, namespaces)
add_node_attrs(s_pid, node_id, node_attrs)
namespaces
end
defp add_node_attrs(s_pid, node_id, node_attrs) do
for {attr, attr_value} <- node_attrs do
set_node_attr(s_pid, node_id, attr, attr_value)
end
end
defp set_node_attr(_s_pid, _node_id, _attr, nil), do: nil
defp set_node_attr(s_pid, node_id, attr, attr_value) do
GenServer.call(s_pid, {:write, {attr, node_id, attr_value}})
end
# TODO: complete the function.
# defp replace_namespace(params, namespaces) do
# for {param, param_value} <- params, reduce: %{} do
# acc ->
# param_value =
# if is_struct(params_value) do
# end
# Map.put
# end
# end
defoverridable start_link: 0,
start_link: 1,
configuration: 1,
address_space: 1,
handle_write: 2
end
end
@doc """
Starts up a OPC UA Server GenServer.
"""
@spec start_link(term(), list()) :: {:ok, pid} | {:error, term} | {:error, :einval}
def start_link(args \\ [], opts \\ []) do
GenServer.start_link(__MODULE__, {args, self()}, opts)
end
@doc """
Stops a OPC UA Server GenServer.
"""
@spec stop(GenServer.server()) :: :ok
def stop(pid) do
GenServer.stop(pid)
end
# Configuration & lifecycle functions
@doc """
Reads an internal Server Config.
"""
@spec get_config(GenServer.server()) :: {:ok, map()} | {:error, binary()} | {:error, :einval}
def get_config(pid) do
GenServer.call(pid, {:config, {:get_server_config, nil}})
end
@doc """
Sets a default Server Config.
"""
@spec set_default_config(GenServer.server()) :: :ok | {:error, binary()} | {:error, :einval}
def set_default_config(pid) do
if(@mix_env != :test) do
GenServer.call(pid, {:config, {:set_default_server_config, nil}})
else
# Valgrind
GenServer.call(pid, {:config, {:set_default_server_config, nil}}, :infinity)
end
end
@doc """
Sets a default Server Config with no network layer and no endpoints.
"""
@spec set_basics(GenServer.server()) :: :ok | {:error, binary()} | {:error, :einval}
def set_basics(pid) do
if(@mix_env != :test) do
GenServer.call(pid, {:config, {:set_basics, nil}})
else
# Valgrind
GenServer.call(pid, {:config, {:set_basics, nil}}, :infinity)
end
end
@doc """
Sets a port number for the Server.
"""
@spec set_network_tcp_layer(GenServer.server(), integer()) :: :ok | {:error, binary()} | {:error, :einval}
def set_network_tcp_layer(pid, port) when is_integer(port) do
if(@mix_env != :test) do
GenServer.call(pid, {:config, {:network_tcp_layer, port}})
else
# Valgrind
GenServer.call(pid, {:config, {:network_tcp_layer, port}}, :infinity)
end
end
@doc """
Sets the host name for the Server.
"""
@spec set_hostname(GenServer.server(), binary()) :: :ok | {:error, binary()} | {:error, :einval}
def set_hostname(pid, hostname) when is_binary(hostname) do
GenServer.call(pid, {:config, {:hostname, hostname}})
end
@doc """
Sets a port number for the Server.
"""
@spec set_port(GenServer.server(), integer()) :: :ok | {:error, binary()} | {:error, :einval}
def set_port(pid, port) when is_integer(port) do
if(@mix_env != :test) do
GenServer.call(pid, {:config, {:port, port}})
else
# Valgrind
GenServer.call(pid, {:config, {:port, port}}, :infinity)
end
end
@doc """
Adds users (and passwords) the Server.
Users must be a tuple list ([{user, password}]).
"""
@spec set_users(GenServer.server(), list()) :: :ok | {:error, binary()} | {:error, :einval}
def set_users(pid, users) when is_list(users) do
GenServer.call(pid, {:config, {:users, users}})
end
@doc """
Adds endpoints for all configured security policies in each mode.
"""
@spec add_all_endpoints(GenServer.server()) :: :ok | {:error, binary()} | {:error, :einval}
def add_all_endpoints(pid) do
if(@mix_env != :test) do
GenServer.call(pid, {:config, {:add_all_endpoints, nil}})
else
# Valgrind
GenServer.call(pid, {:config, {:add_all_endpoints, nil}}, :infinity)
end
end
@doc """
Start OPC UA Server.
"""
@spec start(GenServer.server()) :: :ok | {:error, binary()} | {:error, :einval}
def start(pid) do
GenServer.call(pid, {:start_server, nil})
end
@doc """
Stop OPC UA Server.
"""
@spec stop_server(GenServer.server()) :: :ok | {:error, binary()} | {:error, :einval}
def stop_server(pid) do
GenServer.call(pid, {:stop_server, nil})
end
# Encryption
@doc """
Creates a server configuration with all security policies for the given certificates.
The following must be filled:
* `:private_key` -> binary() or function().
* `:certificate` -> binary() or function().
* `:port` -> interger().
"""
@spec set_default_config_with_certs(GenServer.server(), list()) :: :ok | {:error, binary()} | {:error, :einval}
def set_default_config_with_certs(pid, args) when is_list(args) do
if(@mix_env != :test) do
GenServer.call(pid, {:config, {:all_policies, args}})
else
# Valgrind
GenServer.call(pid, {:config, {:all_policies, args}}, :infinity)
end
end
@doc """
Adds the security policy ``SecurityPolicy#None`` to the server with certicate (no endpoint).
The following must be filled:
* `:certificate` -> binary() or function().
"""
@spec add_none_policy(GenServer.server(), list()) :: :ok | {:error, binary()} | {:error, :einval}
def add_none_policy(pid, args) when is_list(args) do
if(@mix_env != :test) do
GenServer.call(pid, {:config, {:none_policy, args}})
else
# Valgrind
GenServer.call(pid, {:config, {:none_policy, args}}, :infinity)
end
end
@doc """
Adds the security policy ``SecurityPolicy#Basic128Rsa15`` to the server with certicate (no endpoint).
The following must be filled:
* `:private_key` -> binary() or function().
* `:certificate` -> binary() or function().
"""
@spec add_basic128rsa15_policy(GenServer.server(), list()) :: :ok | {:error, binary()} | {:error, :einval}
def add_basic128rsa15_policy(pid, args) when is_list(args) do
if(@mix_env != :test) do
GenServer.call(pid, {:config, {:basic128rsa15_policy, args}})
else
# Valgrind
GenServer.call(pid, {:config, {:basic128rsa15_policy, args}}, :infinity)
end
end
@doc """
Adds the security policy ``SecurityPolicy#Basic256`` to the server with certicate (no endpoint).
The following must be filled:
* `:private_key` -> binary() or function().
* `:certificate` -> binary() or function().
"""
@spec add_basic256_policy(GenServer.server(), list()) :: :ok | {:error, binary()} | {:error, :einval}
def add_basic256_policy(pid, args) when is_list(args) do
if(@mix_env != :test) do
GenServer.call(pid, {:config, {:basic256_policy, args}})
else
# Valgrind
GenServer.call(pid, {:config, {:basic256_policy, args}}, :infinity)
end
end
@doc """
Adds the security policy ``SecurityPolicy#Basic256Sha256`` to the server with certicate (no endpoint).
The following must be filled:
* `:private_key` -> binary() or function().
* `:certificate` -> binary() or function().
"""
@spec add_basic256sha256_policy(GenServer.server(), list()) :: :ok | {:error, binary()} | {:error, :einval}
def add_basic256sha256_policy(pid, args) when is_list(args) do
if(@mix_env != :test) do
GenServer.call(pid, {:config, {:basic256sha256_policy, args}})
else
# Valgrind
GenServer.call(pid, {:config, {:basic256sha256_policy, args}}, :infinity)
end
end
@doc """
Adds all supported security policies and sets up certificate validation procedures (no endpoint).
The following must be filled:
* `:private_key` -> binary() or function().
* `:certificate` -> binary() or function().
"""
@spec add_all_policies(GenServer.server(), list()) :: :ok | {:error, binary()} | {:error, :einval}
def add_all_policies(pid, args) when is_list(args) do
if(@mix_env != :test) do
GenServer.call(pid, {:config, {:all_policies_no_endpoint, args}})
else
# Valgrind
GenServer.call(pid, {:config, {:all_policies_no_endpoint, args}}, :infinity)
end
end
# Discovery functions
@doc """
Sets the configuration for the a Server representing a local discovery server as a central instance.
Any other server can register with this server using "discovery_register" function
NOTE: before calling this function, this server should have the default configuration.
LDS Servers only supports the Discovery Services. Cannot be used in combination with any other capability.
The following args must be filled:
* `:application_uri` -> binary().
* `:timeout` -> boolean().
"""
@spec set_lds_config(GenServer.server(), binary(), integer() | nil) ::
:ok | {:error, binary()} | {:error, :einval}
def set_lds_config(pid, application_uri, timeout \\ nil)
when is_binary(application_uri) and (is_integer(timeout) or is_nil(timeout)) do
GenServer.call(pid, {:discovery, {application_uri, timeout}})
end
@doc """
Registers a server in a discovery server.
NOTE: The Server sends the request once started. Use port = 0 to dynamically port allocation.
The following must be filled:
* `:application_uri` -> binary().
* `:server_name` -> binary().
* `:endpoint` -> binary().
* `:timeout` -> boolean().
"""
@spec discovery_register(GenServer.server(), list()) :: :ok | {:error, binary()} | {:error, :einval}
def discovery_register(pid, args) when is_list(args) do
if(@mix_env != :test) do
GenServer.call(pid, {:discovery, {:discovery_register, args}})
else
# Valgrinnd
GenServer.call(pid, {:discovery, {:discovery_register, args}}, :infinity)
end
end
@doc """
Unregister the server from the discovery server.
NOTE: Server must be started.
"""
@spec discovery_unregister(GenServer.server()) :: :ok | {:error, binary()} | {:error, :einval}
def discovery_unregister(pid) do
GenServer.call(pid, {:discovery, {:discovery_unregister, nil}})
end
# Add & Delete nodes functions
@doc """
Add a new namespace.
"""
@spec add_namespace(GenServer.server(), binary()) ::
{:ok, integer()} | {:error, binary()} | {:error, :einval}
def add_namespace(pid, namespace) when is_binary(namespace) do
GenServer.call(pid, {:add, {:namespace, namespace}})
end
@doc """
Add a new variable node to the server.
The following must be filled:
* `:requested_new_node_id` -> %NodeID{}.
* `:parent_node_id` -> %NodeID{}.
* `:reference_type_node_id` -> %NodeID{}.
* `:browse_name` -> %QualifiedName{}.
* `:type_definition` -> %NodeID{}.
"""
@spec add_variable_node(GenServer.server(), list()) ::
:ok | {:error, binary()} | {:error, :einval}
def add_variable_node(pid, args) when is_list(args) do
GenServer.call(pid, {:add, {:variable_node, args}})
end
@doc """
Add a new variable type node to the server.
The following must be filled:
* `:requested_new_node_id` -> %NodeID{}.
* `:parent_node_id` -> %NodeID{}.
* `:reference_type_node_id` -> %NodeID{}.
* `:browse_name` -> %QualifiedName{}.
* `:type_definition` -> %NodeID{}.
"""
@spec add_variable_type_node(GenServer.server(), list()) ::
:ok | {:error, binary()} | {:error, :einval}
def add_variable_type_node(pid, args) when is_list(args) do
GenServer.call(pid, {:add, {:variable_type_node, args}})
end
@doc """
Add a new object node to the server.
The following must be filled:
* `:requested_new_node_id` -> %NodeID{}.
* `:parent_node_id` -> %NodeID{}.
* `:reference_type_node_id` -> %NodeID{}.
* `:browse_name` -> %QualifiedName{}.
* `:type_definition` -> %NodeID{}.
"""
@spec add_object_node(GenServer.server(), list()) ::
:ok | {:error, binary()} | {:error, :einval}
def add_object_node(pid, args) when is_list(args) do
GenServer.call(pid, {:add, {:object_node, args}})
end
@doc """
Add a new object type node to the server.
The following must be filled:
* `:requested_new_node_id` -> %NodeID{}.
* `:parent_node_id` -> %NodeID{}.
* `:reference_type_node_id` -> %NodeID{}.
* `:browse_name` -> %QualifiedName{}.
"""
@spec add_object_type_node(GenServer.server(), list()) ::
:ok | {:error, binary()} | {:error, :einval}
def add_object_type_node(pid, args) when is_list(args) do
GenServer.call(pid, {:add, {:object_type_node, args}})
end
@doc """
Add a new view node to the server.
The following must be filled:
* `:requested_new_node_id` -> %NodeID{}.
* `:parent_node_id` -> %NodeID{}.
* `:reference_type_node_id` -> %NodeID{}.
* `:browse_name` -> %QualifiedName{}.
"""
@spec add_view_node(GenServer.server(), list()) :: :ok | {:error, binary()} | {:error, :einval}
def add_view_node(pid, args) when is_list(args) do
GenServer.call(pid, {:add, {:view_node, args}})
end
@doc """
Add a new reference type node to the server.
The following must be filled:
* `:requested_new_node_id` -> %NodeID{}.
* `:parent_node_id` -> %NodeID{}.
* `:reference_type_node_id` -> %NodeID{}.
* `:browse_name` -> %QualifiedName{}.
"""
@spec add_reference_type_node(GenServer.server(), list()) ::
:ok | {:error, binary()} | {:error, :einval}
def add_reference_type_node(pid, args) when is_list(args) do
GenServer.call(pid, {:add, {:reference_type_node, args}})
end
@doc """
Add a new data type node to the server.
The following must be filled:
* `:requested_new_node_id` -> %NodeID{}.
* `:parent_node_id` -> %NodeID{}.
* `:reference_type_node_id` -> %NodeID{}.
* `:browse_name` -> %QualifiedName{}.
"""
@spec add_data_type_node(GenServer.server(), list()) ::
:ok | {:error, binary()} | {:error, :einval}
def add_data_type_node(pid, args) when is_list(args) do
GenServer.call(pid, {:add, {:data_type_node, args}})
end
@doc """
Add a new reference in the server.
The following must be filled:
* `:source_id` -> %NodeID{}.
* `:reference_type_id` -> %NodeID{}.
* `:target_id` -> %NodeID{}.
* `:is_forward` -> boolean().
"""
@spec add_reference(GenServer.server(), list()) :: :ok | {:error, binary()} | {:error, :einval}
def add_reference(pid, args) when is_list(args) do
GenServer.call(pid, {:add, {:reference, args}})
end
@doc """
Deletes a reference in the server.
The following must be filled:
* `:source_id` -> %NodeID{}.
* `:reference_type_id` -> %NodeID{}.
* `:target_id` -> %NodeID{}.
* `:is_forward` -> boolean().
* `:delete_bidirectional` -> boolean().
"""
@spec delete_reference(GenServer.server(), list()) ::
:ok | {:error, binary()} | {:error, :einval}
def delete_reference(pid, args) when is_list(args) do
GenServer.call(pid, {:delete_reference, args})
end
@doc """
Deletes a node in the server.
The following must be filled:
* `:node_id` -> %NodeID{}.
* `:delete_references` -> boolean().
"""
@spec delete_node(GenServer.server(), list()) :: :ok | {:error, binary()} | {:error, :einval}
def delete_node(pid, args) when is_list(args) do
GenServer.call(pid, {:delete_node, args})
end
# Add Monitored Items function
@doc """
Create a local MonitoredItem with a sampling interval that detects data changes.
The following must be filled:
* `:monitored_item` -> %NodeID{}.
* `:sampling_time` -> double().
"""
@spec add_monitored_item(GenServer.server(), list()) ::
{:ok, integer()} | {:error, binary()} | {:error, :einval}
def add_monitored_item(pid, args) when is_list(args) do
GenServer.call(pid, {:add, {:monitored_item, args}})
end
@doc """
Deletes a local MonitoredItem.
"""
@spec delete_monitored_item(GenServer.server(), integer()) ::
:ok | {:error, binary()} | {:error, :einval}
def delete_monitored_item(pid, monitored_item_id) when is_integer(monitored_item_id) do
GenServer.call(pid, {:delete_monitored_item, monitored_item_id})
end
@doc false
def test(pid) do
GenServer.call(pid, {:test, nil}, :infinity)
end
# Handlers
def init({_args, controlling_process}) do
lib_dir =
:opex62541
|> :code.priv_dir()
|> to_string()
|> set_ld_library_path()
executable = lib_dir <> "/opc_ua_server"
port = open_port(executable, use_valgrind?())
state = %State{port: port, controlling_process: controlling_process}
{:ok, state}
end
# Handlers Lifecyle & Configuration Functions.
def handle_call({:config, {:get_server_config, nil}}, caller_info, state) do
call_port(state, :get_server_config, caller_info, nil)
{:noreply, state}
end
def handle_call({:config, {:set_default_server_config, nil}}, caller_info, state) do
call_port(state, :set_default_server_config, caller_info, nil)
{:noreply, state}
end
def handle_call({:config, {:set_basics, nil}}, caller_info, state) do
call_port(state, :set_basics, caller_info, nil)
{:noreply, state}
end
def handle_call({:config, {:network_tcp_layer, port}}, caller_info, state) do
call_port(state, :set_network_tcp_layer, caller_info, port)
{:noreply, state}
end
def handle_call({:config, {:hostname, hostname}}, caller_info, state) do
call_port(state, :set_hostname, caller_info, hostname)
{:noreply, state}
end
def handle_call({:config, {:port, port}}, caller_info, state) do
call_port(state, :set_port, caller_info, port)
{:noreply, state}
end
def handle_call({:config, {:users, users}}, caller_info, state) do
call_port(state, :set_users, caller_info, users)
{:noreply, state}
end
def handle_call({:config, {:add_all_endpoints, nil}}, caller_info, state) do
call_port(state, :add_all_endpoints, caller_info, nil)
{:noreply, state}
end
def handle_call({:start_server, nil}, caller_info, state) do
call_port(state, :start_server, caller_info, nil)
{:noreply, state}
end
def handle_call({:stop_server, nil}, caller_info, state) do
call_port(state, :stop_server, caller_info, nil)
{:noreply, state}
end
# Encryption.
def handle_call({:config, {:all_policies, args}}, caller_info, state) do
with cert <- Keyword.fetch!(args, :certificate),
pkey <- Keyword.fetch!(args, :private_key),
port <- Keyword.get(args, :port, nil),
certificate <- get_binary_data(cert),
private_key <- get_binary_data(pkey),
true <- is_binary(certificate),
true <- is_binary(private_key),
true <- is_integer(port) || is_nil(port) do
c_args = {port, certificate, private_key}
call_port(state, :set_config_with_security_policies, caller_info, c_args)
{:noreply, state}
else
_ ->
{:reply, {:error, :einval} ,state}
end
end
def handle_call({:config, {:none_policy, args}}, caller_info, state) do
with cert <- Keyword.fetch!(args, :certificate),
certificate <- get_binary_data(cert),
true <- is_binary(certificate) do
call_port(state, :add_security_policy_none, caller_info, certificate)
{:noreply, state}
else
_ ->
{:reply, {:error, :einval} ,state}
end
end
def handle_call({:config, {:basic128rsa15_policy, args}}, caller_info, state) do
with cert <- Keyword.fetch!(args, :certificate),
pkey <- Keyword.fetch!(args, :private_key),
certificate <- get_binary_data(cert),
private_key <- get_binary_data(pkey),
true <- is_binary(certificate),
true <- is_binary(private_key) do
c_args = {certificate, private_key}
call_port(state, :add_security_policy_basic128rsa15, caller_info, c_args)
{:noreply, state}
else
_ ->
{:reply, {:error, :einval} ,state}
end
end
def handle_call({:config, {:basic256_policy, args}}, caller_info, state) do
with cert <- Keyword.fetch!(args, :certificate),
pkey <- Keyword.fetch!(args, :private_key),
certificate <- get_binary_data(cert),
private_key <- get_binary_data(pkey),
true <- is_binary(certificate),
true <- is_binary(private_key) do
c_args = {certificate, private_key}
call_port(state, :add_security_policy_basic256, caller_info, c_args)
{:noreply, state}
else
_ ->
{:reply, {:error, :einval} ,state}
end
end
def handle_call({:config, {:basic256sha256_policy, args}}, caller_info, state) do
with cert <- Keyword.fetch!(args, :certificate),
pkey <- Keyword.fetch!(args, :private_key),
certificate <- get_binary_data(cert),
private_key <- get_binary_data(pkey),
true <- is_binary(certificate),
true <- is_binary(private_key) do
c_args = {certificate, private_key}
call_port(state, :add_security_policy_basic256sha256, caller_info, c_args)
{:noreply, state}
else
_ ->
{:reply, {:error, :einval} ,state}
end
end
def handle_call({:config, {:all_policies_no_endpoint, args}}, caller_info, state) do
with cert <- Keyword.fetch!(args, :certificate),
pkey <- Keyword.fetch!(args, :private_key),
certificate <- get_binary_data(cert),
private_key <- get_binary_data(pkey),
true <- is_binary(certificate),
true <- is_binary(private_key) do
c_args = {certificate, private_key}
call_port(state, :add_all_security_policies, caller_info, c_args)
{:noreply, state}
else
_ ->
{:reply, {:error, :einval} ,state}
end
end
# Discovery Functions.
def handle_call({:discovery, {:discovery_register, args}}, caller_info, state) do
application_uri = Keyword.fetch!(args, :application_uri)
server_name = Keyword.fetch!(args, :server_name)
endpoint = Keyword.fetch!(args, :endpoint)
timeout = Keyword.get(args, :timeout, nil)
c_args = {application_uri, server_name, endpoint, timeout}
call_port(state, :discovery_register, caller_info, c_args)
{:noreply, state}
end
def handle_call({:discovery, {:discovery_unregister, nil}}, caller_info, state) do
call_port(state, :discovery_unregister, caller_info, nil)
{:noreply, state}
end
def handle_call({:discovery, {application_uri, timeout}}, caller_info, state) do
c_args = {application_uri, timeout}
call_port(state, :set_lds_config, caller_info, c_args)
{:noreply, state}
end
# Handlers Add & Delete Functions.
def handle_call({:add, {:namespace, namespace}}, caller_info, state) do
call_port(state, :add_namespace, caller_info, namespace)
{:noreply, state}
end
def handle_call({:add, {:variable_node, args}}, caller_info, state) do
requested_new_node_id = Keyword.fetch!(args, :requested_new_node_id) |> to_c()
parent_node_id = Keyword.fetch!(args, :parent_node_id) |> to_c()
reference_type_node_id = Keyword.fetch!(args, :reference_type_node_id) |> to_c()
browse_name = Keyword.fetch!(args, :browse_name) |> to_c()
type_definition = Keyword.fetch!(args, :type_definition) |> to_c()
c_args =
{requested_new_node_id, parent_node_id, reference_type_node_id, browse_name,
type_definition}
call_port(state, :add_variable_node, caller_info, c_args)
{:noreply, state}
end
def handle_call({:add, {:variable_type_node, args}}, caller_info, state) do
requested_new_node_id = Keyword.fetch!(args, :requested_new_node_id) |> to_c()
parent_node_id = Keyword.fetch!(args, :parent_node_id) |> to_c()
reference_type_node_id = Keyword.fetch!(args, :reference_type_node_id) |> to_c()
browse_name = Keyword.fetch!(args, :browse_name) |> to_c()
type_definition = Keyword.fetch!(args, :type_definition) |> to_c()
c_args =
{requested_new_node_id, parent_node_id, reference_type_node_id, browse_name,
type_definition}
call_port(state, :add_variable_type_node, caller_info, c_args)
{:noreply, state}
end
def handle_call({:add, {:object_node, args}}, caller_info, state) do
requested_new_node_id = Keyword.fetch!(args, :requested_new_node_id) |> to_c()
parent_node_id = Keyword.fetch!(args, :parent_node_id) |> to_c()
reference_type_node_id = Keyword.fetch!(args, :reference_type_node_id) |> to_c()
browse_name = Keyword.fetch!(args, :browse_name) |> to_c()
type_definition = Keyword.fetch!(args, :type_definition) |> to_c()
c_args =
{requested_new_node_id, parent_node_id, reference_type_node_id, browse_name,
type_definition}
call_port(state, :add_object_node, caller_info, c_args)
{:noreply, state}
end
def handle_call({:add, {:object_type_node, args}}, caller_info, state) do
requested_new_node_id = Keyword.fetch!(args, :requested_new_node_id) |> to_c()
parent_node_id = Keyword.fetch!(args, :parent_node_id) |> to_c()
reference_type_node_id = Keyword.fetch!(args, :reference_type_node_id) |> to_c()
browse_name = Keyword.fetch!(args, :browse_name) |> to_c()
c_args = {requested_new_node_id, parent_node_id, reference_type_node_id, browse_name}
call_port(state, :add_object_type_node, caller_info, c_args)
{:noreply, state}
end
def handle_call({:add, {:view_node, args}}, caller_info, state) do
requested_new_node_id = Keyword.fetch!(args, :requested_new_node_id) |> to_c()
parent_node_id = Keyword.fetch!(args, :parent_node_id) |> to_c()
reference_type_node_id = Keyword.fetch!(args, :reference_type_node_id) |> to_c()
browse_name = Keyword.fetch!(args, :browse_name) |> to_c()
c_args = {requested_new_node_id, parent_node_id, reference_type_node_id, browse_name}
call_port(state, :add_view_node, caller_info, c_args)
{:noreply, state}
end
def handle_call({:add, {:reference_type_node, args}}, caller_info, state) do
requested_new_node_id = Keyword.fetch!(args, :requested_new_node_id) |> to_c()
parent_node_id = Keyword.fetch!(args, :parent_node_id) |> to_c()
reference_type_node_id = Keyword.fetch!(args, :reference_type_node_id) |> to_c()
browse_name = Keyword.fetch!(args, :browse_name) |> to_c()
c_args = {requested_new_node_id, parent_node_id, reference_type_node_id, browse_name}
call_port(state, :add_reference_type_node, caller_info, c_args)
{:noreply, state}
end
def handle_call({:add, {:data_type_node, args}}, caller_info, state) do
requested_new_node_id = Keyword.fetch!(args, :requested_new_node_id) |> to_c()
parent_node_id = Keyword.fetch!(args, :parent_node_id) |> to_c()
reference_type_node_id = Keyword.fetch!(args, :reference_type_node_id) |> to_c()
browse_name = Keyword.fetch!(args, :browse_name) |> to_c()
c_args = {requested_new_node_id, parent_node_id, reference_type_node_id, browse_name}
call_port(state, :add_data_type_node, caller_info, c_args)
{:noreply, state}
end
def handle_call({:add, {:reference, args}}, caller_info, state) do
source_id = Keyword.fetch!(args, :source_id) |> to_c()
reference_type_id = Keyword.fetch!(args, :reference_type_id) |> to_c()
target_id = Keyword.fetch!(args, :target_id) |> to_c()
is_forward = Keyword.fetch!(args, :is_forward)
c_args = {source_id, reference_type_id, target_id, is_forward}
call_port(state, :add_reference, caller_info, c_args)
{:noreply, state}
end
def handle_call({:delete_reference, args}, caller_info, state) do
source_id = Keyword.fetch!(args, :source_id) |> to_c()
reference_type_id = Keyword.fetch!(args, :reference_type_id) |> to_c()
target_id = Keyword.fetch!(args, :target_id) |> to_c()
is_forward = Keyword.fetch!(args, :is_forward)
delete_bidirectional = Keyword.fetch!(args, :delete_bidirectional)
c_args = {source_id, reference_type_id, target_id, is_forward, delete_bidirectional}
call_port(state, :delete_reference, caller_info, c_args)
{:noreply, state}
end
def handle_call({:delete_node, args}, caller_info, state) do
node_id = Keyword.fetch!(args, :node_id) |> to_c()
delete_reference = Keyword.fetch!(args, :delete_reference)
c_args = {node_id, delete_reference}
call_port(state, :delete_node, caller_info, c_args)
{:noreply, state}
end
# Add/delete Monitored Items function
def handle_call({:add, {:monitored_item, args}}, caller_info, state) do
with monitored_item <- Keyword.fetch!(args, :monitored_item) |> to_c(),
sampling_time <- Keyword.fetch!(args, :sampling_time),
true <- is_float(sampling_time) do
c_args = {monitored_item, sampling_time}
call_port(state, :add_monitored_item, caller_info, c_args)
{:noreply, state}
else
_ ->
{:reply, {:error, :einval} ,state}
end
end
def handle_call({:delete_monitored_item, monitored_item_id}, caller_info, state) do
call_port(state, :delete_monitored_item, caller_info, monitored_item_id)
{:noreply, state}
end
# Catch all
def handle_call({:test, nil}, caller_info, state) do
call_port(state, :test, caller_info, nil)
{:noreply, state}
end
def handle_call(invalid_call, _caller_info, state) do
Logger.error("#{__MODULE__} Invalid call: #{inspect(invalid_call)}")
{:reply, {:error, :einval}, state}
end
def handle_info({_port, {:exit_status, code}}, state) do
Logger.warn("(#{__MODULE__}) Error code: #{inspect(code)}.")
# retrying delay
Process.sleep(@c_timeout)
{:stop, :restart, state}
end
def handle_info({:EXIT, _port, reason}, state) do
Logger.debug("(#{__MODULE__}) Exit reason: #{inspect(reason)}")
# retrying delay
Process.sleep(@c_timeout)
{:stop, :restart, state}
end
def handle_info(msg, state) do
Logger.warn("(#{__MODULE__}) Unhandled message: #{inspect(msg)}.")
{:noreply, state}
end
defp handle_c_response(
{:write, {ns_index, type, name}, c_value},
%{controlling_process: c_pid} = state
) do
variable_node = NodeId.new(ns_index: ns_index, identifier_type: type, identifier: name)
value = parse_c_value(c_value)
send(c_pid, {variable_node, value})
state
end
defp handle_c_response({:test, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
# C Handlers Lifecyle & Configuration Functions.
defp handle_c_response({:get_server_config, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:set_default_server_config, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:set_basics, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:set_network_tcp_layer, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:set_hostname, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:set_port, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:set_users, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:add_all_endpoints, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:start_server, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:stop_server, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
# C Encryption function.
defp handle_c_response({:set_config_with_security_policies, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:add_security_policy_none, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:add_security_policy_basic128rsa15, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:add_security_policy_basic256, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:add_security_policy_basic256sha256, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:add_all_security_policies, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
# C Handlers Add & Delete Functions.
defp handle_c_response({:add_namespace, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:add_variable_node, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:add_variable_type_node, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:add_object_node, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:add_object_type_node, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:add_view_node, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:add_reference_type_node, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:add_data_type_node, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:add_reference, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:delete_reference, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:delete_node, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
# C Handlers "Discovery".
defp handle_c_response({:set_lds_config, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:discovery_register, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:discovery_unregister, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
# Add Monitored Items function
defp handle_c_response({:add_monitored_item, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
defp handle_c_response({:delete_monitored_item, caller_metadata, data}, state) do
GenServer.reply(caller_metadata, data)
state
end
end
