pydnp3-stepfunc 1.6.0.3__cp310-cp310-manylinux1_x86_64.whl

dnp3/outstation.py

@@ -0,0 +1,400 @@
+"""
+Outstation (server) implementation for testing purposes.
+
+This allows creating a DNP3 outstation that can be used as a test target.
+"""
+
+from typing import Optional
+
+from ._ffi import ffi, lib, check_error
+from .types import (
+    LinkErrorMode,
+    DecodeLevel,
+)
+from .handler import ConnectionStateListener
+
+
+class EventBufferConfig:
+    """Configuration for event buffer sizes."""
+
+    def __init__(
+        self,
+        binary: int = 10,
+        double_bit_binary: int = 10,
+        binary_output_status: int = 10,
+        counter: int = 5,
+        frozen_counter: int = 5,
+        analog: int = 5,
+        analog_output_status: int = 5,
+        octet_string: int = 3,
+    ):
+        self.binary = binary
+        self.double_bit_binary = double_bit_binary
+        self.binary_output_status = binary_output_status
+        self.counter = counter
+        self.frozen_counter = frozen_counter
+        self.analog = analog
+        self.analog_output_status = analog_output_status
+        self.octet_string = octet_string
+
+    def to_ffi(self):
+        return ffi.new("dnp3_event_buffer_config_t*", {
+            "max_binary": self.binary,
+            "max_double_bit_binary": self.double_bit_binary,
+            "max_binary_output_status": self.binary_output_status,
+            "max_counter": self.counter,
+            "max_frozen_counter": self.frozen_counter,
+            "max_analog": self.analog,
+            "max_analog_output_status": self.analog_output_status,
+            "max_octet_string": self.octet_string,
+        })[0]
+
+
+class OutstationConfig:
+    """Configuration for an outstation."""
+
+    def __init__(
+        self,
+        outstation_address: int = 1024,
+        master_address: int = 1,
+        event_buffer: Optional[EventBufferConfig] = None,
+        decode_level: Optional[DecodeLevel] = None,
+    ):
+        self.outstation_address = outstation_address
+        self.master_address = master_address
+        self.event_buffer = event_buffer or EventBufferConfig()
+        self.decode_level = decode_level or DecodeLevel()
+
+    def to_ffi(self):
+        config = ffi.new("dnp3_outstation_config_t*")
+        config.outstation_address = self.outstation_address
+        config.master_address = self.master_address
+        config.event_buffer_config = self.event_buffer.to_ffi()
+        config.solicited_buffer_size = 2048
+        config.unsolicited_buffer_size = 2048
+        config.rx_buffer_size = 2048
+        config.decode_level = ffi.new("dnp3_decode_level_t*", self.decode_level.to_ffi())[0]
+        config.confirm_timeout = 5000
+        config.select_timeout = 5000
+        # Features — matches dnp3_outstation_features_init() defaults
+        config.features.self_address = False
+        config.features.broadcast = True
+        config.features.unsolicited = True
+        config.features.respond_to_any_master = False
+        config.max_unsolicited_retries = 4294967295  # max uint32
+        config.unsolicited_retry_delay = 5000
+        config.keep_alive_timeout = 60000  # ms
+        config.max_read_request_headers = 64
+        config.max_controls_per_request = 65535
+        # Class zero config — matches dnp3_class_zero_config_init() defaults
+        config.class_zero.binary = True
+        config.class_zero.double_bit_binary = True
+        config.class_zero.binary_output_status = True
+        config.class_zero.counter = True
+        config.class_zero.frozen_counter = True
+        config.class_zero.analog = True
+        config.class_zero.analog_output_status = True
+        config.class_zero.octet_string = False
+        return config[0]
+
+
+class OutstationApplication:
+    """Default outstation application callbacks."""
+
+    def __init__(self):
+        @ffi.callback("uint16_t(void*)")
+        def _get_processing_delay_ms(ctx):
+            return 0
+
+        @ffi.callback("dnp3_write_time_result_t(uint64_t, void*)")
+        def _write_absolute_time(time, ctx):
+            return lib.DNP3_WRITE_TIME_RESULT_OK
+
+        @ffi.callback("dnp3_application_iin_t(void*)")
+        def _get_application_iin(ctx):
+            return ffi.new("dnp3_application_iin_t*", {
+                "need_time": False,
+                "local_control": False,
+                "device_trouble": False,
+                "config_corrupt": False,
+            })[0]
+
+        @ffi.callback("dnp3_restart_delay_t(void*)")
+        def _cold_restart(ctx):
+            return ffi.new("dnp3_restart_delay_t*", {
+                "restart_type": lib.DNP3_RESTART_DELAY_TYPE_SECONDS,
+                "value": 60,
+            })[0]
+
+        @ffi.callback("dnp3_restart_delay_t(void*)")
+        def _warm_restart(ctx):
+            return ffi.new("dnp3_restart_delay_t*", {
+                "restart_type": lib.DNP3_RESTART_DELAY_TYPE_NOT_SUPPORTED,
+                "value": 0,
+            })[0]
+
+        @ffi.callback("dnp3_freeze_result_t(dnp3_freeze_type_t, dnp3_database_handle_t*, void*)")
+        def _freeze_counters_all(freeze_type, db, ctx):
+            return lib.DNP3_FREEZE_RESULT_NOT_SUPPORTED
+
+        @ffi.callback("dnp3_freeze_result_t(uint16_t, uint16_t, dnp3_freeze_type_t, dnp3_database_handle_t*, void*)")
+        def _freeze_counters_range(start, stop, freeze_type, db, ctx):
+            return lib.DNP3_FREEZE_RESULT_NOT_SUPPORTED
+
+        @ffi.callback("bool(uint8_t, uint8_t, dnp3_string_attr_t, const char*, void*)")
+        def _write_string_attr(set_id, var, attr, value, ctx):
+            return True
+
+        self._get_processing_delay_ms = _get_processing_delay_ms
+        self._write_absolute_time = _write_absolute_time
+        self._get_application_iin = _get_application_iin
+        self._cold_restart = _cold_restart
+        self._warm_restart = _warm_restart
+        self._freeze_counters_all = _freeze_counters_all
+        self._freeze_counters_range = _freeze_counters_range
+        self._write_string_attr = _write_string_attr
+
+    def as_ffi(self):
+        return ffi.new("dnp3_outstation_application_t*", {
+            "get_processing_delay_ms": self._get_processing_delay_ms,
+            "write_absolute_time": self._write_absolute_time,
+            "get_application_iin": self._get_application_iin,
+            "cold_restart": self._cold_restart,
+            "warm_restart": self._warm_restart,
+            "freeze_counters_all": self._freeze_counters_all,
+            "freeze_counters_range": self._freeze_counters_range,
+            "write_string_attr": self._write_string_attr,
+            "on_destroy": ffi.NULL,
+            "ctx": ffi.NULL,
+        })[0]
+
+
+class OutstationInformation:
+    """Default outstation information callbacks (no-op)."""
+
+    def __init__(self):
+        @ffi.callback("void(dnp3_request_header_t, void*)")
+        def _noop_header(h, ctx):
+            pass
+
+        @ffi.callback("void(dnp3_function_code_t, dnp3_broadcast_action_t, void*)")
+        def _broadcast_received(fc, action, ctx):
+            pass
+
+        @ffi.callback("void(uint8_t, void*)")
+        def _noop_u8(v, ctx):
+            pass
+
+        @ffi.callback("void(uint8_t, uint8_t, void*)")
+        def _noop_u8_u8(a, b, ctx):
+            pass
+
+        @ffi.callback("void(bool, uint8_t, void*)")
+        def _noop_bool_u8(a, b, ctx):
+            pass
+
+        @ffi.callback("void(uint8_t, bool, void*)")
+        def _noop_u8_bool(a, b, ctx):
+            pass
+
+        @ffi.callback("void(void*)")
+        def _noop(ctx):
+            pass
+
+        self._noop_header = _noop_header
+        self._broadcast_received = _broadcast_received
+        self._noop_u8 = _noop_u8
+        self._noop_u8_u8 = _noop_u8_u8
+        self._noop_bool_u8 = _noop_bool_u8
+        self._noop_u8_bool = _noop_u8_bool
+        self._noop = _noop
+
+    def as_ffi(self):
+        return ffi.new("dnp3_outstation_information_t*", {
+            "process_request_from_idle": self._noop_header,
+            "broadcast_received": self._broadcast_received,
+            "enter_solicited_confirm_wait": self._noop_u8,
+            "solicited_confirm_timeout": self._noop_u8,
+            "solicited_confirm_received": self._noop_u8,
+            "solicited_confirm_wait_new_request": self._noop,
+            "wrong_solicited_confirm_seq": self._noop_u8_u8,
+            "unexpected_confirm": self._noop_bool_u8,
+            "enter_unsolicited_confirm_wait": self._noop_u8,
+            "unsolicited_confirm_timeout": self._noop_u8_bool,
+            "unsolicited_confirmed": self._noop_u8,
+            "clear_restart_iin": self._noop,
+            "on_destroy": ffi.NULL,
+            "ctx": ffi.NULL,
+        })[0]
+
+
+class ControlHandler:
+    """Default control handler (accepts all controls)."""
+
+    def __init__(self):
+        @ffi.callback("void(void*)")
+        def _begin_fragment(ctx):
+            pass
+
+        @ffi.callback("void(dnp3_database_handle_t*, void*)")
+        def _end_fragment(db, ctx):
+            pass
+
+        @ffi.callback("dnp3_command_status_t(dnp3_group12_var1_t, uint16_t, dnp3_database_handle_t*, void*)")
+        def _select_g12v1(control, index, db, ctx):
+            return lib.DNP3_COMMAND_STATUS_SUCCESS
+
+        @ffi.callback("dnp3_command_status_t(dnp3_group12_var1_t, uint16_t, dnp3_operate_type_t, dnp3_database_handle_t*, void*)")
+        def _operate_g12v1(control, index, op_type, db, ctx):
+            return lib.DNP3_COMMAND_STATUS_SUCCESS
+
+        @ffi.callback("dnp3_command_status_t(int32_t, uint16_t, dnp3_database_handle_t*, void*)")
+        def _select_g41v1(value, index, db, ctx):
+            return lib.DNP3_COMMAND_STATUS_SUCCESS
+
+        @ffi.callback("dnp3_command_status_t(int32_t, uint16_t, dnp3_operate_type_t, dnp3_database_handle_t*, void*)")
+        def _operate_g41v1(value, index, op_type, db, ctx):
+            return lib.DNP3_COMMAND_STATUS_SUCCESS
+
+        @ffi.callback("dnp3_command_status_t(int16_t, uint16_t, dnp3_database_handle_t*, void*)")
+        def _select_g41v2(value, index, db, ctx):
+            return lib.DNP3_COMMAND_STATUS_SUCCESS
+
+        @ffi.callback("dnp3_command_status_t(int16_t, uint16_t, dnp3_operate_type_t, dnp3_database_handle_t*, void*)")
+        def _operate_g41v2(value, index, op_type, db, ctx):
+            return lib.DNP3_COMMAND_STATUS_SUCCESS
+
+        @ffi.callback("dnp3_command_status_t(float, uint16_t, dnp3_database_handle_t*, void*)")
+        def _select_g41v3(value, index, db, ctx):
+            return lib.DNP3_COMMAND_STATUS_SUCCESS
+
+        @ffi.callback("dnp3_command_status_t(float, uint16_t, dnp3_operate_type_t, dnp3_database_handle_t*, void*)")
+        def _operate_g41v3(value, index, op_type, db, ctx):
+            return lib.DNP3_COMMAND_STATUS_SUCCESS
+
+        @ffi.callback("dnp3_command_status_t(double, uint16_t, dnp3_database_handle_t*, void*)")
+        def _select_g41v4(value, index, db, ctx):
+            return lib.DNP3_COMMAND_STATUS_SUCCESS
+
+        @ffi.callback("dnp3_command_status_t(double, uint16_t, dnp3_operate_type_t, dnp3_database_handle_t*, void*)")
+        def _operate_g41v4(value, index, op_type, db, ctx):
+            return lib.DNP3_COMMAND_STATUS_SUCCESS
+
+        self._begin_fragment = _begin_fragment
+        self._end_fragment = _end_fragment
+        self._select_g12v1 = _select_g12v1
+        self._operate_g12v1 = _operate_g12v1
+        self._select_g41v1 = _select_g41v1
+        self._operate_g41v1 = _operate_g41v1
+        self._select_g41v2 = _select_g41v2
+        self._operate_g41v2 = _operate_g41v2
+        self._select_g41v3 = _select_g41v3
+        self._operate_g41v3 = _operate_g41v3
+        self._select_g41v4 = _select_g41v4
+        self._operate_g41v4 = _operate_g41v4
+
+    def as_ffi(self):
+        return ffi.new("dnp3_control_handler_t*", {
+            "begin_fragment": self._begin_fragment,
+            "end_fragment": self._end_fragment,
+            "select_g12v1": self._select_g12v1,
+            "operate_g12v1": self._operate_g12v1,
+            "select_g41v1": self._select_g41v1,
+            "operate_g41v1": self._operate_g41v1,
+            "select_g41v2": self._select_g41v2,
+            "operate_g41v2": self._operate_g41v2,
+            "select_g41v3": self._select_g41v3,
+            "operate_g41v3": self._operate_g41v3,
+            "select_g41v4": self._select_g41v4,
+            "operate_g41v4": self._operate_g41v4,
+            "on_destroy": ffi.NULL,
+            "ctx": ffi.NULL,
+        })[0]
+
+
+class OutstationServer:
+    """
+    TCP outstation server for testing purposes.
+
+    Creates a server that accepts master connections.
+    """
+
+    def __init__(
+        self,
+        runtime,
+        address: str = "127.0.0.1:20000",
+        link_error_mode: LinkErrorMode = LinkErrorMode.CLOSE,
+    ):
+        self._runtime = runtime
+        self._outstations = []
+        self._destroyed = False
+
+        server_ptr = ffi.new("dnp3_outstation_server_t**")
+        err = lib.dnp3_outstation_server_create_tcp_server(
+            runtime._ptr,
+            link_error_mode.value,
+            address.encode(),
+            server_ptr,
+        )
+        check_error(err)
+        self._ptr = server_ptr[0]
+
+    def add_outstation(
+        self,
+        config: Optional[OutstationConfig] = None,
+        application: Optional[OutstationApplication] = None,
+        information: Optional[OutstationInformation] = None,
+        control_handler: Optional[ControlHandler] = None,
+        listener: Optional[ConnectionStateListener] = None,
+    ):
+        """Add an outstation to the server."""
+        config = config or OutstationConfig()
+        application = application or OutstationApplication()
+        information = information or OutstationInformation()
+        control_handler = control_handler or ControlHandler()
+        listener = listener or ConnectionStateListener()
+
+        # Keep references
+        self._app = application
+        self._info = information
+        self._ctrl = control_handler
+        self._listener = listener
+
+        address_filter = lib.dnp3_address_filter_any()
+        outstation_ptr = ffi.new("dnp3_outstation_t**")
+
+        err = lib.dnp3_outstation_server_add_outstation(
+            self._ptr,
+            config.to_ffi(),
+            application.as_ffi(),
+            information.as_ffi(),
+            control_handler.as_ffi(),
+            listener.as_ffi(),
+            address_filter,
+            outstation_ptr,
+        )
+        lib.dnp3_address_filter_destroy(address_filter)
+        check_error(err)
+
+        self._outstations.append(outstation_ptr[0])
+        return outstation_ptr[0]
+
+    def bind(self):
+        """Start accepting connections."""
+        check_error(lib.dnp3_outstation_server_bind(self._ptr))
+
+    def destroy(self):
+        """Clean up all outstations and the server."""
+        if self._destroyed:
+            return
+        self._destroyed = True
+        for os in self._outstations:
+            lib.dnp3_outstation_destroy(os)
+        self._outstations.clear()
+        lib.dnp3_outstation_server_destroy(self._ptr)
+
+    def __del__(self):
+        try:
+            self.destroy()
+        except Exception:
+            pass

dnp3/runtime.py

@@ -0,0 +1,57 @@
+"""
+DNP3 runtime management.
+
+The runtime manages the Tokio async runtime used by the Rust library.
+It must be created before any channels and destroyed after all channels.
+"""
+
+from ._ffi import ffi, lib, check_error
+
+
+class Runtime:
+    """
+    Manages the underlying Tokio async runtime.
+
+    Usage:
+        runtime = Runtime(num_threads=4)
+        # ... create channels ...
+        runtime.destroy()
+
+    Or as a context manager:
+        with Runtime() as runtime:
+            channel = create_tcp_channel(runtime, ...)
+    """
+
+    def __init__(self, num_threads: int = 0):
+        """
+        Create a new runtime.
+
+        Args:
+            num_threads: Number of worker threads. 0 = auto-detect from CPU count.
+        """
+        rt_ptr = ffi.new("dnp3_runtime_t**")
+        config = ffi.new("dnp3_runtime_config_t*", {"num_core_threads": num_threads})
+        err = lib.dnp3_runtime_create(config[0], rt_ptr)
+        check_error(err)
+        self._ptr = rt_ptr[0]
+        self._destroyed = False
+
+    def set_shutdown_timeout(self, timeout_secs: int):
+        """Set maximum time to wait during shutdown."""
+        lib.dnp3_runtime_set_shutdown_timeout(self._ptr, timeout_secs)
+
+    def destroy(self):
+        """Destroy the runtime. Blocks until all tasks complete."""
+        if not self._destroyed and self._ptr is not None:
+            lib.dnp3_runtime_destroy(self._ptr)
+            self._destroyed = True
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.destroy()
+        return False
+
+    def __del__(self):
+        self.destroy()